<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html lang="en">

<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>LCOV - coverage_clean.info - 13/bits/shared_ptr.h</title>
  <link rel="stylesheet" type="text/css" href="../../gcov.css">
</head>

<body>

          <table width="100%" border=0 cellspacing=0 cellpadding=0>
            <tr><td class="title">LCOV - code coverage report</td></tr>
            <tr><td class="ruler"><img src="../../glass.png" width=3 height=3 alt=""></td></tr>

            <tr>
              <td width="100%">
                <table cellpadding=1 border=0 width="100%">
          <tr>
            <td width="10%" class="headerItem">Current view:</td>
            <td width="10%" class="headerValue"><a href="../../index.html">top level</a> - <a href="index.html">13/bits</a> - shared_ptr.h<span style="font-size: 80%;"> (source / <a href="shared_ptr.h.func-c.html">functions</a>)</span></td>
            <td width="5%"></td>
            <td width="5%"></td>
            <td width="5%" class="headerCovTableHead">Coverage</td>
            <td width="5%" class="headerCovTableHead" title="Covered + Uncovered code">Total</td>
            <td width="5%" class="headerCovTableHead" title="Exercised code only">Hit</td>
          </tr>
          <tr>
            <td class="headerItem">Test:</td>
            <td class="headerValue">coverage_clean.info</td>
            <td></td>
            <td class="headerItem">Lines:</td>
            <td class="headerCovTableEntryHi">100.0&nbsp;%</td>
            <td class="headerCovTableEntry">9</td>
            <td class="headerCovTableEntry">9</td>
          </tr>
          <tr>
            <td class="headerItem">Test Date:</td>
            <td class="headerValue">2025-11-25 04:45:29</td>
            <td></td>
            <td class="headerItem">Functions:</td>
            <td class="headerCovTableEntryHi">100.0&nbsp;%</td>
            <td class="headerCovTableEntry">4</td>
            <td class="headerCovTableEntry">4</td>
          </tr>
                  <tr><td><img src="../../glass.png" width=3 height=3 alt=""></td></tr>
                </table>
              </td>
            </tr>

            <tr><td class="ruler"><img src="../../glass.png" width=3 height=3 alt=""></td></tr>
          </table>

          <table cellpadding=0 cellspacing=0 border=0>
            <tr>
              <td><br></td>
            </tr>
            <tr>
              <td>
<pre class="sourceHeading">            Line data    Source code</pre>
<pre class="source">
<span id="L1"><span class="lineNum">       1</span>              : // shared_ptr and weak_ptr implementation -*- C++ -*-</span>
<span id="L2"><span class="lineNum">       2</span>              : </span>
<span id="L3"><span class="lineNum">       3</span>              : // Copyright (C) 2007-2023 Free Software Foundation, Inc.</span>
<span id="L4"><span class="lineNum">       4</span>              : //</span>
<span id="L5"><span class="lineNum">       5</span>              : // This file is part of the GNU ISO C++ Library.  This library is free</span>
<span id="L6"><span class="lineNum">       6</span>              : // software; you can redistribute it and/or modify it under the</span>
<span id="L7"><span class="lineNum">       7</span>              : // terms of the GNU General Public License as published by the</span>
<span id="L8"><span class="lineNum">       8</span>              : // Free Software Foundation; either version 3, or (at your option)</span>
<span id="L9"><span class="lineNum">       9</span>              : // any later version.</span>
<span id="L10"><span class="lineNum">      10</span>              : </span>
<span id="L11"><span class="lineNum">      11</span>              : // This library is distributed in the hope that it will be useful,</span>
<span id="L12"><span class="lineNum">      12</span>              : // but WITHOUT ANY WARRANTY; without even the implied warranty of</span>
<span id="L13"><span class="lineNum">      13</span>              : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the</span>
<span id="L14"><span class="lineNum">      14</span>              : // GNU General Public License for more details.</span>
<span id="L15"><span class="lineNum">      15</span>              : </span>
<span id="L16"><span class="lineNum">      16</span>              : // Under Section 7 of GPL version 3, you are granted additional</span>
<span id="L17"><span class="lineNum">      17</span>              : // permissions described in the GCC Runtime Library Exception, version</span>
<span id="L18"><span class="lineNum">      18</span>              : // 3.1, as published by the Free Software Foundation.</span>
<span id="L19"><span class="lineNum">      19</span>              : </span>
<span id="L20"><span class="lineNum">      20</span>              : // You should have received a copy of the GNU General Public License and</span>
<span id="L21"><span class="lineNum">      21</span>              : // a copy of the GCC Runtime Library Exception along with this program;</span>
<span id="L22"><span class="lineNum">      22</span>              : // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see</span>
<span id="L23"><span class="lineNum">      23</span>              : // &lt;http://www.gnu.org/licenses/&gt;.</span>
<span id="L24"><span class="lineNum">      24</span>              : </span>
<span id="L25"><span class="lineNum">      25</span>              : // GCC Note: Based on files from version 1.32.0 of the Boost library.</span>
<span id="L26"><span class="lineNum">      26</span>              : </span>
<span id="L27"><span class="lineNum">      27</span>              : //  shared_count.hpp</span>
<span id="L28"><span class="lineNum">      28</span>              : //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.</span>
<span id="L29"><span class="lineNum">      29</span>              : </span>
<span id="L30"><span class="lineNum">      30</span>              : //  shared_ptr.hpp</span>
<span id="L31"><span class="lineNum">      31</span>              : //  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.</span>
<span id="L32"><span class="lineNum">      32</span>              : //  Copyright (C) 2001, 2002, 2003 Peter Dimov</span>
<span id="L33"><span class="lineNum">      33</span>              : </span>
<span id="L34"><span class="lineNum">      34</span>              : //  weak_ptr.hpp</span>
<span id="L35"><span class="lineNum">      35</span>              : //  Copyright (C) 2001, 2002, 2003 Peter Dimov</span>
<span id="L36"><span class="lineNum">      36</span>              : </span>
<span id="L37"><span class="lineNum">      37</span>              : //  enable_shared_from_this.hpp</span>
<span id="L38"><span class="lineNum">      38</span>              : //  Copyright (C) 2002 Peter Dimov</span>
<span id="L39"><span class="lineNum">      39</span>              : </span>
<span id="L40"><span class="lineNum">      40</span>              : // Distributed under the Boost Software License, Version 1.0. (See</span>
<span id="L41"><span class="lineNum">      41</span>              : // accompanying file LICENSE_1_0.txt or copy at</span>
<span id="L42"><span class="lineNum">      42</span>              : // http://www.boost.org/LICENSE_1_0.txt)</span>
<span id="L43"><span class="lineNum">      43</span>              : </span>
<span id="L44"><span class="lineNum">      44</span>              : /** @file</span>
<span id="L45"><span class="lineNum">      45</span>              :  *  This is an internal header file, included by other library headers.</span>
<span id="L46"><span class="lineNum">      46</span>              :  *  Do not attempt to use it directly. @headername{memory}</span>
<span id="L47"><span class="lineNum">      47</span>              :  */</span>
<span id="L48"><span class="lineNum">      48</span>              : </span>
<span id="L49"><span class="lineNum">      49</span>              : #ifndef _SHARED_PTR_H</span>
<span id="L50"><span class="lineNum">      50</span>              : #define _SHARED_PTR_H 1</span>
<span id="L51"><span class="lineNum">      51</span>              : </span>
<span id="L52"><span class="lineNum">      52</span>              : #include &lt;iosfwd&gt;                   // std::basic_ostream</span>
<span id="L53"><span class="lineNum">      53</span>              : #include &lt;bits/shared_ptr_base.h&gt;</span>
<span id="L54"><span class="lineNum">      54</span>              : </span>
<span id="L55"><span class="lineNum">      55</span>              : namespace std _GLIBCXX_VISIBILITY(default)</span>
<span id="L56"><span class="lineNum">      56</span>              : {</span>
<span id="L57"><span class="lineNum">      57</span>              : _GLIBCXX_BEGIN_NAMESPACE_VERSION</span>
<span id="L58"><span class="lineNum">      58</span>              : </span>
<span id="L59"><span class="lineNum">      59</span>              :   /**</span>
<span id="L60"><span class="lineNum">      60</span>              :    * @addtogroup pointer_abstractions</span>
<span id="L61"><span class="lineNum">      61</span>              :    * @{</span>
<span id="L62"><span class="lineNum">      62</span>              :    */</span>
<span id="L63"><span class="lineNum">      63</span>              : </span>
<span id="L64"><span class="lineNum">      64</span>              :   // 20.7.2.2.11 shared_ptr I/O</span>
<span id="L65"><span class="lineNum">      65</span>              : </span>
<span id="L66"><span class="lineNum">      66</span>              :   /// Write the stored pointer to an ostream.</span>
<span id="L67"><span class="lineNum">      67</span>              :   /// @relates shared_ptr</span>
<span id="L68"><span class="lineNum">      68</span>              :   template&lt;typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp&gt;</span>
<span id="L69"><span class="lineNum">      69</span>              :     inline std::basic_ostream&lt;_Ch, _Tr&gt;&amp;</span>
<span id="L70"><span class="lineNum">      70</span>              :     operator&lt;&lt;(std::basic_ostream&lt;_Ch, _Tr&gt;&amp; __os,</span>
<span id="L71"><span class="lineNum">      71</span>              :                const __shared_ptr&lt;_Tp, _Lp&gt;&amp; __p)</span>
<span id="L72"><span class="lineNum">      72</span>              :     {</span>
<span id="L73"><span class="lineNum">      73</span>              :       __os &lt;&lt; __p.get();</span>
<span id="L74"><span class="lineNum">      74</span>              :       return __os;</span>
<span id="L75"><span class="lineNum">      75</span>              :     }</span>
<span id="L76"><span class="lineNum">      76</span>              : </span>
<span id="L77"><span class="lineNum">      77</span>              :   template&lt;typename _Del, typename _Tp, _Lock_policy _Lp&gt;</span>
<span id="L78"><span class="lineNum">      78</span>              :     inline _Del*</span>
<span id="L79"><span class="lineNum">      79</span>              :     get_deleter(const __shared_ptr&lt;_Tp, _Lp&gt;&amp; __p) noexcept</span>
<span id="L80"><span class="lineNum">      80</span>              :     {</span>
<span id="L81"><span class="lineNum">      81</span>              : #if __cpp_rtti</span>
<span id="L82"><span class="lineNum">      82</span>              :       return static_cast&lt;_Del*&gt;(__p._M_get_deleter(typeid(_Del)));</span>
<span id="L83"><span class="lineNum">      83</span>              : #else</span>
<span id="L84"><span class="lineNum">      84</span>              :       return 0;</span>
<span id="L85"><span class="lineNum">      85</span>              : #endif</span>
<span id="L86"><span class="lineNum">      86</span>              :     }</span>
<span id="L87"><span class="lineNum">      87</span>              : </span>
<span id="L88"><span class="lineNum">      88</span>              :   /// 20.7.2.2.10 shared_ptr get_deleter</span>
<span id="L89"><span class="lineNum">      89</span>              : </span>
<span id="L90"><span class="lineNum">      90</span>              :   /// If `__p` has a deleter of type `_Del`, return a pointer to it.</span>
<span id="L91"><span class="lineNum">      91</span>              :   /// @relates shared_ptr</span>
<span id="L92"><span class="lineNum">      92</span>              :   template&lt;typename _Del, typename _Tp&gt;</span>
<span id="L93"><span class="lineNum">      93</span>              :     inline _Del*</span>
<span id="L94"><span class="lineNum">      94</span>              :     get_deleter(const shared_ptr&lt;_Tp&gt;&amp; __p) noexcept</span>
<span id="L95"><span class="lineNum">      95</span>              :     {</span>
<span id="L96"><span class="lineNum">      96</span>              : #if __cpp_rtti</span>
<span id="L97"><span class="lineNum">      97</span>              :       return static_cast&lt;_Del*&gt;(__p._M_get_deleter(typeid(_Del)));</span>
<span id="L98"><span class="lineNum">      98</span>              : #else</span>
<span id="L99"><span class="lineNum">      99</span>              :       return 0;</span>
<span id="L100"><span class="lineNum">     100</span>              : #endif</span>
<span id="L101"><span class="lineNum">     101</span>              :     }</span>
<span id="L102"><span class="lineNum">     102</span>              : </span>
<span id="L103"><span class="lineNum">     103</span>              :   /// @cond undocumented</span>
<span id="L104"><span class="lineNum">     104</span>              : </span>
<span id="L105"><span class="lineNum">     105</span>              :   // Constraint for overloads taking non-array types.</span>
<span id="L106"><span class="lineNum">     106</span>              : #if __cpp_concepts &amp;&amp; __cpp_lib_type_trait_variable_templates</span>
<span id="L107"><span class="lineNum">     107</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L108"><span class="lineNum">     108</span>              :     requires (!is_array_v&lt;_Tp&gt;)</span>
<span id="L109"><span class="lineNum">     109</span>              :     using _NonArray = _Tp;</span>
<span id="L110"><span class="lineNum">     110</span>              : #else</span>
<span id="L111"><span class="lineNum">     111</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L112"><span class="lineNum">     112</span>              :     using _NonArray = __enable_if_t&lt;!is_array&lt;_Tp&gt;::value, _Tp&gt;;</span>
<span id="L113"><span class="lineNum">     113</span>              : #endif</span>
<span id="L114"><span class="lineNum">     114</span>              : </span>
<span id="L115"><span class="lineNum">     115</span>              : #if __cpp_lib_shared_ptr_arrays &gt;= 201707L</span>
<span id="L116"><span class="lineNum">     116</span>              :   // Constraint for overloads taking array types with unknown bound, U[].</span>
<span id="L117"><span class="lineNum">     117</span>              : #if __cpp_concepts</span>
<span id="L118"><span class="lineNum">     118</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L119"><span class="lineNum">     119</span>              :     requires is_array_v&lt;_Tp&gt; &amp;&amp; (extent_v&lt;_Tp&gt; == 0)</span>
<span id="L120"><span class="lineNum">     120</span>              :     using _UnboundedArray = _Tp;</span>
<span id="L121"><span class="lineNum">     121</span>              : #else</span>
<span id="L122"><span class="lineNum">     122</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L123"><span class="lineNum">     123</span>              :     using _UnboundedArray</span>
<span id="L124"><span class="lineNum">     124</span>              :       = __enable_if_t&lt;__is_array_unknown_bounds&lt;_Tp&gt;::value, _Tp&gt;;</span>
<span id="L125"><span class="lineNum">     125</span>              : #endif</span>
<span id="L126"><span class="lineNum">     126</span>              : </span>
<span id="L127"><span class="lineNum">     127</span>              :   // Constraint for overloads taking array types with known bound, U[N].</span>
<span id="L128"><span class="lineNum">     128</span>              : #if __cpp_concepts</span>
<span id="L129"><span class="lineNum">     129</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L130"><span class="lineNum">     130</span>              :     requires (extent_v&lt;_Tp&gt; != 0)</span>
<span id="L131"><span class="lineNum">     131</span>              :     using _BoundedArray = _Tp;</span>
<span id="L132"><span class="lineNum">     132</span>              : #else</span>
<span id="L133"><span class="lineNum">     133</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L134"><span class="lineNum">     134</span>              :     using _BoundedArray</span>
<span id="L135"><span class="lineNum">     135</span>              :       = __enable_if_t&lt;__is_array_known_bounds&lt;_Tp&gt;::value, _Tp&gt;;</span>
<span id="L136"><span class="lineNum">     136</span>              : #endif</span>
<span id="L137"><span class="lineNum">     137</span>              : </span>
<span id="L138"><span class="lineNum">     138</span>              : #if __cpp_lib_smart_ptr_for_overwrite</span>
<span id="L139"><span class="lineNum">     139</span>              :   // Constraint for overloads taking either non-array or bounded array, U[N].</span>
<span id="L140"><span class="lineNum">     140</span>              : #if __cpp_concepts</span>
<span id="L141"><span class="lineNum">     141</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L142"><span class="lineNum">     142</span>              :     requires (!is_array_v&lt;_Tp&gt;) || (extent_v&lt;_Tp&gt; != 0)</span>
<span id="L143"><span class="lineNum">     143</span>              :     using _NotUnboundedArray = _Tp;</span>
<span id="L144"><span class="lineNum">     144</span>              : #else</span>
<span id="L145"><span class="lineNum">     145</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L146"><span class="lineNum">     146</span>              :     using _NotUnboundedArray</span>
<span id="L147"><span class="lineNum">     147</span>              :       = __enable_if_t&lt;!__is_array_unknown_bounds&lt;_Tp&gt;::value, _Tp&gt;;</span>
<span id="L148"><span class="lineNum">     148</span>              : #endif</span>
<span id="L149"><span class="lineNum">     149</span>              : #endif // smart_ptr_for_overwrite</span>
<span id="L150"><span class="lineNum">     150</span>              : #endif // shared_ptr_arrays</span>
<span id="L151"><span class="lineNum">     151</span>              : </span>
<span id="L152"><span class="lineNum">     152</span>              :   /// @endcond</span>
<span id="L153"><span class="lineNum">     153</span>              : </span>
<span id="L154"><span class="lineNum">     154</span>              :   /**</span>
<span id="L155"><span class="lineNum">     155</span>              :    *  @brief  A smart pointer with reference-counted copy semantics.</span>
<span id="L156"><span class="lineNum">     156</span>              :    *  @headerfile memory</span>
<span id="L157"><span class="lineNum">     157</span>              :    *  @since C++11</span>
<span id="L158"><span class="lineNum">     158</span>              :    *</span>
<span id="L159"><span class="lineNum">     159</span>              :    * A `shared_ptr` object is either empty or _owns_ a pointer passed</span>
<span id="L160"><span class="lineNum">     160</span>              :    * to the constructor. Copies of a `shared_ptr` share ownership of</span>
<span id="L161"><span class="lineNum">     161</span>              :    * the same pointer. When the last `shared_ptr` that owns the pointer</span>
<span id="L162"><span class="lineNum">     162</span>              :    * is destroyed or reset, the owned pointer is freed (either by `delete`</span>
<span id="L163"><span class="lineNum">     163</span>              :    * or by invoking a custom deleter that was passed to the constructor).</span>
<span id="L164"><span class="lineNum">     164</span>              :    *</span>
<span id="L165"><span class="lineNum">     165</span>              :    * A `shared_ptr` also stores another pointer, which is usually</span>
<span id="L166"><span class="lineNum">     166</span>              :    * (but not always) the same pointer as it owns. The stored pointer</span>
<span id="L167"><span class="lineNum">     167</span>              :    * can be retrieved by calling the `get()` member function.</span>
<span id="L168"><span class="lineNum">     168</span>              :    *</span>
<span id="L169"><span class="lineNum">     169</span>              :    * The equality and relational operators for `shared_ptr` only compare</span>
<span id="L170"><span class="lineNum">     170</span>              :    * the stored pointer returned by `get()`, not the owned pointer.</span>
<span id="L171"><span class="lineNum">     171</span>              :    * To test whether two `shared_ptr` objects share ownership of the same</span>
<span id="L172"><span class="lineNum">     172</span>              :    * pointer see `std::shared_ptr::owner_before` and `std::owner_less`.</span>
<span id="L173"><span class="lineNum">     173</span>              :   */</span>
<span id="L174"><span class="lineNum">     174</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L175"><span class="lineNum">     175</span>              :     class shared_ptr : public __shared_ptr&lt;_Tp&gt;</span>
<span id="L176"><span class="lineNum">     176</span>              :     {</span>
<span id="L177"><span class="lineNum">     177</span>              :       template&lt;typename... _Args&gt;</span>
<span id="L178"><span class="lineNum">     178</span>              :         using _Constructible = typename enable_if&lt;</span>
<span id="L179"><span class="lineNum">     179</span>              :           is_constructible&lt;__shared_ptr&lt;_Tp&gt;, _Args...&gt;::value</span>
<span id="L180"><span class="lineNum">     180</span>              :         &gt;::type;</span>
<span id="L181"><span class="lineNum">     181</span>              : </span>
<span id="L182"><span class="lineNum">     182</span>              :       template&lt;typename _Arg&gt;</span>
<span id="L183"><span class="lineNum">     183</span>              :         using _Assignable = typename enable_if&lt;</span>
<span id="L184"><span class="lineNum">     184</span>              :           is_assignable&lt;__shared_ptr&lt;_Tp&gt;&amp;, _Arg&gt;::value, shared_ptr&amp;</span>
<span id="L185"><span class="lineNum">     185</span>              :         &gt;::type;</span>
<span id="L186"><span class="lineNum">     186</span>              : </span>
<span id="L187"><span class="lineNum">     187</span>              :     public:</span>
<span id="L188"><span class="lineNum">     188</span>              : </span>
<span id="L189"><span class="lineNum">     189</span>              :       /// The type pointed to by the stored pointer, remove_extent_t&lt;_Tp&gt;</span>
<span id="L190"><span class="lineNum">     190</span>              :       using element_type = typename __shared_ptr&lt;_Tp&gt;::element_type;</span>
<span id="L191"><span class="lineNum">     191</span>              : </span>
<span id="L192"><span class="lineNum">     192</span>              : #if __cplusplus &gt;= 201703L</span>
<span id="L193"><span class="lineNum">     193</span>              : # define __cpp_lib_shared_ptr_weak_type 201606L</span>
<span id="L194"><span class="lineNum">     194</span>              :       /// The corresponding weak_ptr type for this shared_ptr</span>
<span id="L195"><span class="lineNum">     195</span>              :       /// @since C++17</span>
<span id="L196"><span class="lineNum">     196</span>              :       using weak_type = weak_ptr&lt;_Tp&gt;;</span>
<span id="L197"><span class="lineNum">     197</span>              : #endif</span>
<span id="L198"><span class="lineNum">     198</span>              :       /**</span>
<span id="L199"><span class="lineNum">     199</span>              :        *  @brief  Construct an empty %shared_ptr.</span>
<span id="L200"><span class="lineNum">     200</span>              :        *  @post   use_count()==0 &amp;&amp; get()==0</span>
<span id="L201"><span class="lineNum">     201</span>              :        */</span>
<span id="L202"><span class="lineNum">     202</span> <span class="tlaGNC tlaBgGNC">           2 :       constexpr shared_ptr() noexcept : __shared_ptr&lt;_Tp&gt;() { }</span></span>
<span id="L203"><span class="lineNum">     203</span>              : </span>
<span id="L204"><span class="lineNum">     204</span>              :       shared_ptr(const shared_ptr&amp;) noexcept = default; ///&lt; Copy constructor</span>
<span id="L205"><span class="lineNum">     205</span>              : </span>
<span id="L206"><span class="lineNum">     206</span>              :       /**</span>
<span id="L207"><span class="lineNum">     207</span>              :        *  @brief  Construct a %shared_ptr that owns the pointer @a __p.</span>
<span id="L208"><span class="lineNum">     208</span>              :        *  @param  __p  A pointer that is convertible to element_type*.</span>
<span id="L209"><span class="lineNum">     209</span>              :        *  @post   use_count() == 1 &amp;&amp; get() == __p</span>
<span id="L210"><span class="lineNum">     210</span>              :        *  @throw  std::bad_alloc, in which case @c delete @a __p is called.</span>
<span id="L211"><span class="lineNum">     211</span>              :        */</span>
<span id="L212"><span class="lineNum">     212</span>              :       template&lt;typename _Yp, typename = _Constructible&lt;_Yp*&gt;&gt;</span>
<span id="L213"><span class="lineNum">     213</span>              :         explicit</span>
<span id="L214"><span class="lineNum">     214</span>              :         shared_ptr(_Yp* __p) : __shared_ptr&lt;_Tp&gt;(__p) { }</span>
<span id="L215"><span class="lineNum">     215</span>              : </span>
<span id="L216"><span class="lineNum">     216</span>              :       /**</span>
<span id="L217"><span class="lineNum">     217</span>              :        *  @brief  Construct a %shared_ptr that owns the pointer @a __p</span>
<span id="L218"><span class="lineNum">     218</span>              :        *          and the deleter @a __d.</span>
<span id="L219"><span class="lineNum">     219</span>              :        *  @param  __p  A pointer.</span>
<span id="L220"><span class="lineNum">     220</span>              :        *  @param  __d  A deleter.</span>
<span id="L221"><span class="lineNum">     221</span>              :        *  @post   use_count() == 1 &amp;&amp; get() == __p</span>
<span id="L222"><span class="lineNum">     222</span>              :        *  @throw  std::bad_alloc, in which case @a __d(__p) is called.</span>
<span id="L223"><span class="lineNum">     223</span>              :        *</span>
<span id="L224"><span class="lineNum">     224</span>              :        *  Requirements: _Deleter's copy constructor and destructor must</span>
<span id="L225"><span class="lineNum">     225</span>              :        *  not throw</span>
<span id="L226"><span class="lineNum">     226</span>              :        *</span>
<span id="L227"><span class="lineNum">     227</span>              :        *  __shared_ptr will release __p by calling __d(__p)</span>
<span id="L228"><span class="lineNum">     228</span>              :        */</span>
<span id="L229"><span class="lineNum">     229</span>              :       template&lt;typename _Yp, typename _Deleter,</span>
<span id="L230"><span class="lineNum">     230</span>              :                typename = _Constructible&lt;_Yp*, _Deleter&gt;&gt;</span>
<span id="L231"><span class="lineNum">     231</span>              :         shared_ptr(_Yp* __p, _Deleter __d)</span>
<span id="L232"><span class="lineNum">     232</span>              :         : __shared_ptr&lt;_Tp&gt;(__p, std::move(__d)) { }</span>
<span id="L233"><span class="lineNum">     233</span>              : </span>
<span id="L234"><span class="lineNum">     234</span>              :       /**</span>
<span id="L235"><span class="lineNum">     235</span>              :        *  @brief  Construct a %shared_ptr that owns a null pointer</span>
<span id="L236"><span class="lineNum">     236</span>              :        *          and the deleter @a __d.</span>
<span id="L237"><span class="lineNum">     237</span>              :        *  @param  __p  A null pointer constant.</span>
<span id="L238"><span class="lineNum">     238</span>              :        *  @param  __d  A deleter.</span>
<span id="L239"><span class="lineNum">     239</span>              :        *  @post   use_count() == 1 &amp;&amp; get() == __p</span>
<span id="L240"><span class="lineNum">     240</span>              :        *  @throw  std::bad_alloc, in which case @a __d(__p) is called.</span>
<span id="L241"><span class="lineNum">     241</span>              :        *</span>
<span id="L242"><span class="lineNum">     242</span>              :        *  Requirements: _Deleter's copy constructor and destructor must</span>
<span id="L243"><span class="lineNum">     243</span>              :        *  not throw</span>
<span id="L244"><span class="lineNum">     244</span>              :        *</span>
<span id="L245"><span class="lineNum">     245</span>              :        *  The last owner will call __d(__p)</span>
<span id="L246"><span class="lineNum">     246</span>              :        */</span>
<span id="L247"><span class="lineNum">     247</span>              :       template&lt;typename _Deleter&gt;</span>
<span id="L248"><span class="lineNum">     248</span>              :         shared_ptr(nullptr_t __p, _Deleter __d)</span>
<span id="L249"><span class="lineNum">     249</span>              :         : __shared_ptr&lt;_Tp&gt;(__p, std::move(__d)) { }</span>
<span id="L250"><span class="lineNum">     250</span>              : </span>
<span id="L251"><span class="lineNum">     251</span>              :       /**</span>
<span id="L252"><span class="lineNum">     252</span>              :        *  @brief  Construct a %shared_ptr that owns the pointer @a __p</span>
<span id="L253"><span class="lineNum">     253</span>              :        *          and the deleter @a __d.</span>
<span id="L254"><span class="lineNum">     254</span>              :        *  @param  __p  A pointer.</span>
<span id="L255"><span class="lineNum">     255</span>              :        *  @param  __d  A deleter.</span>
<span id="L256"><span class="lineNum">     256</span>              :        *  @param  __a  An allocator.</span>
<span id="L257"><span class="lineNum">     257</span>              :        *  @post   use_count() == 1 &amp;&amp; get() == __p</span>
<span id="L258"><span class="lineNum">     258</span>              :        *  @throw  std::bad_alloc, in which case @a __d(__p) is called.</span>
<span id="L259"><span class="lineNum">     259</span>              :        *</span>
<span id="L260"><span class="lineNum">     260</span>              :        *  Requirements: _Deleter's copy constructor and destructor must</span>
<span id="L261"><span class="lineNum">     261</span>              :        *  not throw _Alloc's copy constructor and destructor must not</span>
<span id="L262"><span class="lineNum">     262</span>              :        *  throw.</span>
<span id="L263"><span class="lineNum">     263</span>              :        *</span>
<span id="L264"><span class="lineNum">     264</span>              :        *  __shared_ptr will release __p by calling __d(__p)</span>
<span id="L265"><span class="lineNum">     265</span>              :        */</span>
<span id="L266"><span class="lineNum">     266</span>              :       template&lt;typename _Yp, typename _Deleter, typename _Alloc,</span>
<span id="L267"><span class="lineNum">     267</span>              :                typename = _Constructible&lt;_Yp*, _Deleter, _Alloc&gt;&gt;</span>
<span id="L268"><span class="lineNum">     268</span>              :         shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)</span>
<span id="L269"><span class="lineNum">     269</span>              :         : __shared_ptr&lt;_Tp&gt;(__p, std::move(__d), std::move(__a)) { }</span>
<span id="L270"><span class="lineNum">     270</span>              : </span>
<span id="L271"><span class="lineNum">     271</span>              :       /**</span>
<span id="L272"><span class="lineNum">     272</span>              :        *  @brief  Construct a %shared_ptr that owns a null pointer</span>
<span id="L273"><span class="lineNum">     273</span>              :        *          and the deleter @a __d.</span>
<span id="L274"><span class="lineNum">     274</span>              :        *  @param  __p  A null pointer constant.</span>
<span id="L275"><span class="lineNum">     275</span>              :        *  @param  __d  A deleter.</span>
<span id="L276"><span class="lineNum">     276</span>              :        *  @param  __a  An allocator.</span>
<span id="L277"><span class="lineNum">     277</span>              :        *  @post   use_count() == 1 &amp;&amp; get() == __p</span>
<span id="L278"><span class="lineNum">     278</span>              :        *  @throw  std::bad_alloc, in which case @a __d(__p) is called.</span>
<span id="L279"><span class="lineNum">     279</span>              :        *</span>
<span id="L280"><span class="lineNum">     280</span>              :        *  Requirements: _Deleter's copy constructor and destructor must</span>
<span id="L281"><span class="lineNum">     281</span>              :        *  not throw _Alloc's copy constructor and destructor must not</span>
<span id="L282"><span class="lineNum">     282</span>              :        *  throw.</span>
<span id="L283"><span class="lineNum">     283</span>              :        *</span>
<span id="L284"><span class="lineNum">     284</span>              :        *  The last owner will call __d(__p)</span>
<span id="L285"><span class="lineNum">     285</span>              :        */</span>
<span id="L286"><span class="lineNum">     286</span>              :       template&lt;typename _Deleter, typename _Alloc&gt;</span>
<span id="L287"><span class="lineNum">     287</span>              :         shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)</span>
<span id="L288"><span class="lineNum">     288</span>              :         : __shared_ptr&lt;_Tp&gt;(__p, std::move(__d), std::move(__a)) { }</span>
<span id="L289"><span class="lineNum">     289</span>              : </span>
<span id="L290"><span class="lineNum">     290</span>              :       // Aliasing constructor</span>
<span id="L291"><span class="lineNum">     291</span>              : </span>
<span id="L292"><span class="lineNum">     292</span>              :       /**</span>
<span id="L293"><span class="lineNum">     293</span>              :        *  @brief  Constructs a `shared_ptr` instance that stores `__p`</span>
<span id="L294"><span class="lineNum">     294</span>              :        *          and shares ownership with `__r`.</span>
<span id="L295"><span class="lineNum">     295</span>              :        *  @param  __r  A `shared_ptr`.</span>
<span id="L296"><span class="lineNum">     296</span>              :        *  @param  __p  A pointer that will remain valid while `*__r` is valid.</span>
<span id="L297"><span class="lineNum">     297</span>              :        *  @post   `get() == __p &amp;&amp; use_count() == __r.use_count()`</span>
<span id="L298"><span class="lineNum">     298</span>              :        *</span>
<span id="L299"><span class="lineNum">     299</span>              :        *  This can be used to construct a `shared_ptr` to a sub-object</span>
<span id="L300"><span class="lineNum">     300</span>              :        *  of an object managed by an existing `shared_ptr`. The complete</span>
<span id="L301"><span class="lineNum">     301</span>              :        *  object will remain valid while any `shared_ptr` owns it, even</span>
<span id="L302"><span class="lineNum">     302</span>              :        *  if they don't store a pointer to the complete object.</span>
<span id="L303"><span class="lineNum">     303</span>              :        *</span>
<span id="L304"><span class="lineNum">     304</span>              :        * @code</span>
<span id="L305"><span class="lineNum">     305</span>              :        * shared_ptr&lt;pair&lt;int,int&gt;&gt; pii(new pair&lt;int,int&gt;());</span>
<span id="L306"><span class="lineNum">     306</span>              :        * shared_ptr&lt;int&gt; pi(pii, &amp;pii-&gt;first);</span>
<span id="L307"><span class="lineNum">     307</span>              :        * assert(pii.use_count() == 2);</span>
<span id="L308"><span class="lineNum">     308</span>              :        * @endcode</span>
<span id="L309"><span class="lineNum">     309</span>              :        */</span>
<span id="L310"><span class="lineNum">     310</span>              :       template&lt;typename _Yp&gt;</span>
<span id="L311"><span class="lineNum">     311</span>              :         shared_ptr(const shared_ptr&lt;_Yp&gt;&amp; __r, element_type* __p) noexcept</span>
<span id="L312"><span class="lineNum">     312</span>              :         : __shared_ptr&lt;_Tp&gt;(__r, __p) { }</span>
<span id="L313"><span class="lineNum">     313</span>              : </span>
<span id="L314"><span class="lineNum">     314</span>              : #if __cplusplus &gt; 201703L</span>
<span id="L315"><span class="lineNum">     315</span>              :       // _GLIBCXX_RESOLVE_LIB_DEFECTS</span>
<span id="L316"><span class="lineNum">     316</span>              :       // 2996. Missing rvalue overloads for shared_ptr operations</span>
<span id="L317"><span class="lineNum">     317</span>              :       /**</span>
<span id="L318"><span class="lineNum">     318</span>              :        *  @brief  Constructs a `shared_ptr` instance that stores `__p`</span>
<span id="L319"><span class="lineNum">     319</span>              :        *          and shares ownership with `__r`.</span>
<span id="L320"><span class="lineNum">     320</span>              :        *  @param  __r  A `shared_ptr`.</span>
<span id="L321"><span class="lineNum">     321</span>              :        *  @param  __p  A pointer that will remain valid while `*__r` is valid.</span>
<span id="L322"><span class="lineNum">     322</span>              :        *  @post   `get() == __p &amp;&amp; !__r.use_count() &amp;&amp; !__r.get()`</span>
<span id="L323"><span class="lineNum">     323</span>              :        *  @since C++17</span>
<span id="L324"><span class="lineNum">     324</span>              :        *</span>
<span id="L325"><span class="lineNum">     325</span>              :        *  This can be used to construct a `shared_ptr` to a sub-object</span>
<span id="L326"><span class="lineNum">     326</span>              :        *  of an object managed by an existing `shared_ptr`. The complete</span>
<span id="L327"><span class="lineNum">     327</span>              :        *  object will remain valid while any `shared_ptr` owns it, even</span>
<span id="L328"><span class="lineNum">     328</span>              :        *  if they don't store a pointer to the complete object.</span>
<span id="L329"><span class="lineNum">     329</span>              :        *</span>
<span id="L330"><span class="lineNum">     330</span>              :        * @code</span>
<span id="L331"><span class="lineNum">     331</span>              :        * shared_ptr&lt;pair&lt;int,int&gt;&gt; pii(new pair&lt;int,int&gt;());</span>
<span id="L332"><span class="lineNum">     332</span>              :        * shared_ptr&lt;int&gt; pi1(pii, &amp;pii-&gt;first);</span>
<span id="L333"><span class="lineNum">     333</span>              :        * assert(pii.use_count() == 2);</span>
<span id="L334"><span class="lineNum">     334</span>              :        * shared_ptr&lt;int&gt; pi2(std::move(pii), &amp;pii-&gt;second);</span>
<span id="L335"><span class="lineNum">     335</span>              :        * assert(pii.use_count() == 0);</span>
<span id="L336"><span class="lineNum">     336</span>              :        * @endcode</span>
<span id="L337"><span class="lineNum">     337</span>              :        */</span>
<span id="L338"><span class="lineNum">     338</span>              :       template&lt;typename _Yp&gt;</span>
<span id="L339"><span class="lineNum">     339</span>              :         shared_ptr(shared_ptr&lt;_Yp&gt;&amp;&amp; __r, element_type* __p) noexcept</span>
<span id="L340"><span class="lineNum">     340</span>              :         : __shared_ptr&lt;_Tp&gt;(std::move(__r), __p) { }</span>
<span id="L341"><span class="lineNum">     341</span>              : #endif</span>
<span id="L342"><span class="lineNum">     342</span>              :       /**</span>
<span id="L343"><span class="lineNum">     343</span>              :        *  @brief  If @a __r is empty, constructs an empty %shared_ptr;</span>
<span id="L344"><span class="lineNum">     344</span>              :        *          otherwise construct a %shared_ptr that shares ownership</span>
<span id="L345"><span class="lineNum">     345</span>              :        *          with @a __r.</span>
<span id="L346"><span class="lineNum">     346</span>              :        *  @param  __r  A %shared_ptr.</span>
<span id="L347"><span class="lineNum">     347</span>              :        *  @post   get() == __r.get() &amp;&amp; use_count() == __r.use_count()</span>
<span id="L348"><span class="lineNum">     348</span>              :        */</span>
<span id="L349"><span class="lineNum">     349</span>              :       template&lt;typename _Yp,</span>
<span id="L350"><span class="lineNum">     350</span>              :                typename = _Constructible&lt;const shared_ptr&lt;_Yp&gt;&amp;&gt;&gt;</span>
<span id="L351"><span class="lineNum">     351</span>              :         shared_ptr(const shared_ptr&lt;_Yp&gt;&amp; __r) noexcept</span>
<span id="L352"><span class="lineNum">     352</span>              :         : __shared_ptr&lt;_Tp&gt;(__r) { }</span>
<span id="L353"><span class="lineNum">     353</span>              : </span>
<span id="L354"><span class="lineNum">     354</span>              :       /**</span>
<span id="L355"><span class="lineNum">     355</span>              :        *  @brief  Move-constructs a %shared_ptr instance from @a __r.</span>
<span id="L356"><span class="lineNum">     356</span>              :        *  @param  __r  A %shared_ptr rvalue.</span>
<span id="L357"><span class="lineNum">     357</span>              :        *  @post   *this contains the old value of @a __r, @a __r is empty.</span>
<span id="L358"><span class="lineNum">     358</span>              :        */</span>
<span id="L359"><span class="lineNum">     359</span>              :       shared_ptr(shared_ptr&amp;&amp; __r) noexcept</span>
<span id="L360"><span class="lineNum">     360</span>              :       : __shared_ptr&lt;_Tp&gt;(std::move(__r)) { }</span>
<span id="L361"><span class="lineNum">     361</span>              : </span>
<span id="L362"><span class="lineNum">     362</span>              :       /**</span>
<span id="L363"><span class="lineNum">     363</span>              :        *  @brief  Move-constructs a %shared_ptr instance from @a __r.</span>
<span id="L364"><span class="lineNum">     364</span>              :        *  @param  __r  A %shared_ptr rvalue.</span>
<span id="L365"><span class="lineNum">     365</span>              :        *  @post   *this contains the old value of @a __r, @a __r is empty.</span>
<span id="L366"><span class="lineNum">     366</span>              :        */</span>
<span id="L367"><span class="lineNum">     367</span>              :       template&lt;typename _Yp, typename = _Constructible&lt;shared_ptr&lt;_Yp&gt;&gt;&gt;</span>
<span id="L368"><span class="lineNum">     368</span>              :         shared_ptr(shared_ptr&lt;_Yp&gt;&amp;&amp; __r) noexcept</span>
<span id="L369"><span class="lineNum">     369</span>              :         : __shared_ptr&lt;_Tp&gt;(std::move(__r)) { }</span>
<span id="L370"><span class="lineNum">     370</span>              : </span>
<span id="L371"><span class="lineNum">     371</span>              :       /**</span>
<span id="L372"><span class="lineNum">     372</span>              :        *  @brief  Constructs a %shared_ptr that shares ownership with @a __r</span>
<span id="L373"><span class="lineNum">     373</span>              :        *          and stores a copy of the pointer stored in @a __r.</span>
<span id="L374"><span class="lineNum">     374</span>              :        *  @param  __r  A weak_ptr.</span>
<span id="L375"><span class="lineNum">     375</span>              :        *  @post   use_count() == __r.use_count()</span>
<span id="L376"><span class="lineNum">     376</span>              :        *  @throw  bad_weak_ptr when __r.expired(),</span>
<span id="L377"><span class="lineNum">     377</span>              :        *          in which case the constructor has no effect.</span>
<span id="L378"><span class="lineNum">     378</span>              :        */</span>
<span id="L379"><span class="lineNum">     379</span>              :       template&lt;typename _Yp, typename = _Constructible&lt;const weak_ptr&lt;_Yp&gt;&amp;&gt;&gt;</span>
<span id="L380"><span class="lineNum">     380</span>              :         explicit shared_ptr(const weak_ptr&lt;_Yp&gt;&amp; __r)</span>
<span id="L381"><span class="lineNum">     381</span>              :         : __shared_ptr&lt;_Tp&gt;(__r) { }</span>
<span id="L382"><span class="lineNum">     382</span>              : </span>
<span id="L383"><span class="lineNum">     383</span>              : #if _GLIBCXX_USE_DEPRECATED</span>
<span id="L384"><span class="lineNum">     384</span>              : #pragma GCC diagnostic push</span>
<span id="L385"><span class="lineNum">     385</span>              : #pragma GCC diagnostic ignored &quot;-Wdeprecated-declarations&quot;</span>
<span id="L386"><span class="lineNum">     386</span>              :       template&lt;typename _Yp, typename = _Constructible&lt;auto_ptr&lt;_Yp&gt;&gt;&gt;</span>
<span id="L387"><span class="lineNum">     387</span>              :         shared_ptr(auto_ptr&lt;_Yp&gt;&amp;&amp; __r);</span>
<span id="L388"><span class="lineNum">     388</span>              : #pragma GCC diagnostic pop</span>
<span id="L389"><span class="lineNum">     389</span>              : #endif</span>
<span id="L390"><span class="lineNum">     390</span>              : </span>
<span id="L391"><span class="lineNum">     391</span>              :       // _GLIBCXX_RESOLVE_LIB_DEFECTS</span>
<span id="L392"><span class="lineNum">     392</span>              :       // 2399. shared_ptr's constructor from unique_ptr should be constrained</span>
<span id="L393"><span class="lineNum">     393</span>              :       template&lt;typename _Yp, typename _Del,</span>
<span id="L394"><span class="lineNum">     394</span>              :                typename = _Constructible&lt;unique_ptr&lt;_Yp, _Del&gt;&gt;&gt;</span>
<span id="L395"><span class="lineNum">     395</span>              :         shared_ptr(unique_ptr&lt;_Yp, _Del&gt;&amp;&amp; __r)</span>
<span id="L396"><span class="lineNum">     396</span>              :         : __shared_ptr&lt;_Tp&gt;(std::move(__r)) { }</span>
<span id="L397"><span class="lineNum">     397</span>              : </span>
<span id="L398"><span class="lineNum">     398</span>              : #if __cplusplus &lt;= 201402L &amp;&amp; _GLIBCXX_USE_DEPRECATED</span>
<span id="L399"><span class="lineNum">     399</span>              :       // This non-standard constructor exists to support conversions that</span>
<span id="L400"><span class="lineNum">     400</span>              :       // were possible in C++11 and C++14 but are ill-formed in C++17.</span>
<span id="L401"><span class="lineNum">     401</span>              :       // If an exception is thrown this constructor has no effect.</span>
<span id="L402"><span class="lineNum">     402</span>              :       template&lt;typename _Yp, typename _Del,</span>
<span id="L403"><span class="lineNum">     403</span>              :                 _Constructible&lt;unique_ptr&lt;_Yp, _Del&gt;, __sp_array_delete&gt;* = 0&gt;</span>
<span id="L404"><span class="lineNum">     404</span>              :         shared_ptr(unique_ptr&lt;_Yp, _Del&gt;&amp;&amp; __r)</span>
<span id="L405"><span class="lineNum">     405</span>              :         : __shared_ptr&lt;_Tp&gt;(std::move(__r), __sp_array_delete()) { }</span>
<span id="L406"><span class="lineNum">     406</span>              : #endif</span>
<span id="L407"><span class="lineNum">     407</span>              : </span>
<span id="L408"><span class="lineNum">     408</span>              :       /**</span>
<span id="L409"><span class="lineNum">     409</span>              :        *  @brief  Construct an empty %shared_ptr.</span>
<span id="L410"><span class="lineNum">     410</span>              :        *  @post   use_count() == 0 &amp;&amp; get() == nullptr</span>
<span id="L411"><span class="lineNum">     411</span>              :        */</span>
<span id="L412"><span class="lineNum">     412</span>              :       constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }</span>
<span id="L413"><span class="lineNum">     413</span>              : </span>
<span id="L414"><span class="lineNum">     414</span>              :       shared_ptr&amp; operator=(const shared_ptr&amp;) noexcept = default;</span>
<span id="L415"><span class="lineNum">     415</span>              : </span>
<span id="L416"><span class="lineNum">     416</span>              :       template&lt;typename _Yp&gt;</span>
<span id="L417"><span class="lineNum">     417</span>              :         _Assignable&lt;const shared_ptr&lt;_Yp&gt;&amp;&gt;</span>
<span id="L418"><span class="lineNum">     418</span>              :         operator=(const shared_ptr&lt;_Yp&gt;&amp; __r) noexcept</span>
<span id="L419"><span class="lineNum">     419</span>              :         {</span>
<span id="L420"><span class="lineNum">     420</span>              :           this-&gt;__shared_ptr&lt;_Tp&gt;::operator=(__r);</span>
<span id="L421"><span class="lineNum">     421</span>              :           return *this;</span>
<span id="L422"><span class="lineNum">     422</span>              :         }</span>
<span id="L423"><span class="lineNum">     423</span>              : </span>
<span id="L424"><span class="lineNum">     424</span>              : #if _GLIBCXX_USE_DEPRECATED</span>
<span id="L425"><span class="lineNum">     425</span>              : #pragma GCC diagnostic push</span>
<span id="L426"><span class="lineNum">     426</span>              : #pragma GCC diagnostic ignored &quot;-Wdeprecated-declarations&quot;</span>
<span id="L427"><span class="lineNum">     427</span>              :       template&lt;typename _Yp&gt;</span>
<span id="L428"><span class="lineNum">     428</span>              :         _Assignable&lt;auto_ptr&lt;_Yp&gt;&gt;</span>
<span id="L429"><span class="lineNum">     429</span>              :         operator=(auto_ptr&lt;_Yp&gt;&amp;&amp; __r)</span>
<span id="L430"><span class="lineNum">     430</span>              :         {</span>
<span id="L431"><span class="lineNum">     431</span>              :           this-&gt;__shared_ptr&lt;_Tp&gt;::operator=(std::move(__r));</span>
<span id="L432"><span class="lineNum">     432</span>              :           return *this;</span>
<span id="L433"><span class="lineNum">     433</span>              :         }</span>
<span id="L434"><span class="lineNum">     434</span>              : #pragma GCC diagnostic pop</span>
<span id="L435"><span class="lineNum">     435</span>              : #endif</span>
<span id="L436"><span class="lineNum">     436</span>              : </span>
<span id="L437"><span class="lineNum">     437</span>              :       shared_ptr&amp;</span>
<span id="L438"><span class="lineNum">     438</span> <span class="tlaGNC">           2 :       operator=(shared_ptr&amp;&amp; __r) noexcept</span></span>
<span id="L439"><span class="lineNum">     439</span>              :       {</span>
<span id="L440"><span class="lineNum">     440</span> <span class="tlaGNC">           2 :         this-&gt;__shared_ptr&lt;_Tp&gt;::operator=(std::move(__r));</span></span>
<span id="L441"><span class="lineNum">     441</span> <span class="tlaGNC">           2 :         return *this;</span></span>
<span id="L442"><span class="lineNum">     442</span>              :       }</span>
<span id="L443"><span class="lineNum">     443</span>              : </span>
<span id="L444"><span class="lineNum">     444</span>              :       template&lt;class _Yp&gt;</span>
<span id="L445"><span class="lineNum">     445</span>              :         _Assignable&lt;shared_ptr&lt;_Yp&gt;&gt;</span>
<span id="L446"><span class="lineNum">     446</span>              :         operator=(shared_ptr&lt;_Yp&gt;&amp;&amp; __r) noexcept</span>
<span id="L447"><span class="lineNum">     447</span>              :         {</span>
<span id="L448"><span class="lineNum">     448</span>              :           this-&gt;__shared_ptr&lt;_Tp&gt;::operator=(std::move(__r));</span>
<span id="L449"><span class="lineNum">     449</span>              :           return *this;</span>
<span id="L450"><span class="lineNum">     450</span>              :         }</span>
<span id="L451"><span class="lineNum">     451</span>              : </span>
<span id="L452"><span class="lineNum">     452</span>              :       template&lt;typename _Yp, typename _Del&gt;</span>
<span id="L453"><span class="lineNum">     453</span>              :         _Assignable&lt;unique_ptr&lt;_Yp, _Del&gt;&gt;</span>
<span id="L454"><span class="lineNum">     454</span>              :         operator=(unique_ptr&lt;_Yp, _Del&gt;&amp;&amp; __r)</span>
<span id="L455"><span class="lineNum">     455</span>              :         {</span>
<span id="L456"><span class="lineNum">     456</span>              :           this-&gt;__shared_ptr&lt;_Tp&gt;::operator=(std::move(__r));</span>
<span id="L457"><span class="lineNum">     457</span>              :           return *this;</span>
<span id="L458"><span class="lineNum">     458</span>              :         }</span>
<span id="L459"><span class="lineNum">     459</span>              : </span>
<span id="L460"><span class="lineNum">     460</span>              :     private:</span>
<span id="L461"><span class="lineNum">     461</span>              :       // This constructor is non-standard, it is used by allocate_shared.</span>
<span id="L462"><span class="lineNum">     462</span>              :       template&lt;typename _Alloc, typename... _Args&gt;</span>
<span id="L463"><span class="lineNum">     463</span> <span class="tlaGNC">           2 :         shared_ptr(_Sp_alloc_shared_tag&lt;_Alloc&gt; __tag, _Args&amp;&amp;... __args)</span></span>
<span id="L464"><span class="lineNum">     464</span> <span class="tlaGNC">           2 :         : __shared_ptr&lt;_Tp&gt;(__tag, std::forward&lt;_Args&gt;(__args)...)</span></span>
<span id="L465"><span class="lineNum">     465</span> <span class="tlaGNC">           2 :         { }</span></span>
<span id="L466"><span class="lineNum">     466</span>              : </span>
<span id="L467"><span class="lineNum">     467</span>              :       template&lt;typename _Yp, typename _Alloc, typename... _Args&gt;</span>
<span id="L468"><span class="lineNum">     468</span>              :         friend shared_ptr&lt;_NonArray&lt;_Yp&gt;&gt;</span>
<span id="L469"><span class="lineNum">     469</span>              :         allocate_shared(const _Alloc&amp;, _Args&amp;&amp;...);</span>
<span id="L470"><span class="lineNum">     470</span>              : </span>
<span id="L471"><span class="lineNum">     471</span>              :       template&lt;typename _Yp, typename... _Args&gt;</span>
<span id="L472"><span class="lineNum">     472</span>              :         friend shared_ptr&lt;_NonArray&lt;_Yp&gt;&gt;</span>
<span id="L473"><span class="lineNum">     473</span>              :         make_shared(_Args&amp;&amp;...);</span>
<span id="L474"><span class="lineNum">     474</span>              : </span>
<span id="L475"><span class="lineNum">     475</span>              : #if __cpp_lib_shared_ptr_arrays &gt;= 201707L</span>
<span id="L476"><span class="lineNum">     476</span>              :       // This constructor is non-standard, it is used by allocate_shared&lt;T[]&gt;.</span>
<span id="L477"><span class="lineNum">     477</span>              :       template&lt;typename _Alloc, typename _Init = const remove_extent_t&lt;_Tp&gt;*&gt;</span>
<span id="L478"><span class="lineNum">     478</span>              :         shared_ptr(const _Sp_counted_array_base&lt;_Alloc&gt;&amp; __a,</span>
<span id="L479"><span class="lineNum">     479</span>              :                    _Init __init = nullptr)</span>
<span id="L480"><span class="lineNum">     480</span>              :         : __shared_ptr&lt;_Tp&gt;(__a, __init)</span>
<span id="L481"><span class="lineNum">     481</span>              :         { }</span>
<span id="L482"><span class="lineNum">     482</span>              : </span>
<span id="L483"><span class="lineNum">     483</span>              :       template&lt;typename _Yp, typename _Alloc&gt;</span>
<span id="L484"><span class="lineNum">     484</span>              :         friend shared_ptr&lt;_UnboundedArray&lt;_Yp&gt;&gt;</span>
<span id="L485"><span class="lineNum">     485</span>              :         allocate_shared(const _Alloc&amp;, size_t);</span>
<span id="L486"><span class="lineNum">     486</span>              : </span>
<span id="L487"><span class="lineNum">     487</span>              :       template&lt;typename _Yp&gt;</span>
<span id="L488"><span class="lineNum">     488</span>              :         friend shared_ptr&lt;_UnboundedArray&lt;_Yp&gt;&gt;</span>
<span id="L489"><span class="lineNum">     489</span>              :         make_shared(size_t);</span>
<span id="L490"><span class="lineNum">     490</span>              : </span>
<span id="L491"><span class="lineNum">     491</span>              :       template&lt;typename _Yp, typename _Alloc&gt;</span>
<span id="L492"><span class="lineNum">     492</span>              :         friend shared_ptr&lt;_UnboundedArray&lt;_Yp&gt;&gt;</span>
<span id="L493"><span class="lineNum">     493</span>              :         allocate_shared(const _Alloc&amp;, size_t, const remove_extent_t&lt;_Yp&gt;&amp;);</span>
<span id="L494"><span class="lineNum">     494</span>              : </span>
<span id="L495"><span class="lineNum">     495</span>              :       template&lt;typename _Yp&gt;</span>
<span id="L496"><span class="lineNum">     496</span>              :         friend shared_ptr&lt;_UnboundedArray&lt;_Yp&gt;&gt;</span>
<span id="L497"><span class="lineNum">     497</span>              :         make_shared(size_t, const remove_extent_t&lt;_Yp&gt;&amp;);</span>
<span id="L498"><span class="lineNum">     498</span>              : </span>
<span id="L499"><span class="lineNum">     499</span>              :       template&lt;typename _Yp, typename _Alloc&gt;</span>
<span id="L500"><span class="lineNum">     500</span>              :         friend shared_ptr&lt;_BoundedArray&lt;_Yp&gt;&gt;</span>
<span id="L501"><span class="lineNum">     501</span>              :         allocate_shared(const _Alloc&amp;);</span>
<span id="L502"><span class="lineNum">     502</span>              : </span>
<span id="L503"><span class="lineNum">     503</span>              :       template&lt;typename _Yp&gt;</span>
<span id="L504"><span class="lineNum">     504</span>              :         friend shared_ptr&lt;_BoundedArray&lt;_Yp&gt;&gt;</span>
<span id="L505"><span class="lineNum">     505</span>              :         make_shared();</span>
<span id="L506"><span class="lineNum">     506</span>              : </span>
<span id="L507"><span class="lineNum">     507</span>              :       template&lt;typename _Yp, typename _Alloc&gt;</span>
<span id="L508"><span class="lineNum">     508</span>              :         friend shared_ptr&lt;_BoundedArray&lt;_Yp&gt;&gt;</span>
<span id="L509"><span class="lineNum">     509</span>              :         allocate_shared(const _Alloc&amp;, const remove_extent_t&lt;_Yp&gt;&amp;);</span>
<span id="L510"><span class="lineNum">     510</span>              : </span>
<span id="L511"><span class="lineNum">     511</span>              :       template&lt;typename _Yp&gt;</span>
<span id="L512"><span class="lineNum">     512</span>              :         friend shared_ptr&lt;_BoundedArray&lt;_Yp&gt;&gt;</span>
<span id="L513"><span class="lineNum">     513</span>              :         make_shared(const remove_extent_t&lt;_Yp&gt;&amp;);</span>
<span id="L514"><span class="lineNum">     514</span>              : </span>
<span id="L515"><span class="lineNum">     515</span>              : #if __cpp_lib_smart_ptr_for_overwrite</span>
<span id="L516"><span class="lineNum">     516</span>              :       template&lt;typename _Yp, typename _Alloc&gt;</span>
<span id="L517"><span class="lineNum">     517</span>              :         friend shared_ptr&lt;_NotUnboundedArray&lt;_Yp&gt;&gt;</span>
<span id="L518"><span class="lineNum">     518</span>              :         allocate_shared_for_overwrite(const _Alloc&amp;);</span>
<span id="L519"><span class="lineNum">     519</span>              : </span>
<span id="L520"><span class="lineNum">     520</span>              :       template&lt;typename _Yp&gt;</span>
<span id="L521"><span class="lineNum">     521</span>              :         friend shared_ptr&lt;_NotUnboundedArray&lt;_Yp&gt;&gt;</span>
<span id="L522"><span class="lineNum">     522</span>              :         make_shared_for_overwrite();</span>
<span id="L523"><span class="lineNum">     523</span>              : </span>
<span id="L524"><span class="lineNum">     524</span>              :       template&lt;typename _Yp, typename _Alloc&gt;</span>
<span id="L525"><span class="lineNum">     525</span>              :         friend shared_ptr&lt;_UnboundedArray&lt;_Yp&gt;&gt;</span>
<span id="L526"><span class="lineNum">     526</span>              :         allocate_shared_for_overwrite(const _Alloc&amp;, size_t);</span>
<span id="L527"><span class="lineNum">     527</span>              : </span>
<span id="L528"><span class="lineNum">     528</span>              :       template&lt;typename _Yp&gt;</span>
<span id="L529"><span class="lineNum">     529</span>              :         friend shared_ptr&lt;_UnboundedArray&lt;_Yp&gt;&gt;</span>
<span id="L530"><span class="lineNum">     530</span>              :         make_shared_for_overwrite(size_t);</span>
<span id="L531"><span class="lineNum">     531</span>              : #endif</span>
<span id="L532"><span class="lineNum">     532</span>              : #endif</span>
<span id="L533"><span class="lineNum">     533</span>              : </span>
<span id="L534"><span class="lineNum">     534</span>              :       // This constructor is non-standard, it is used by weak_ptr::lock().</span>
<span id="L535"><span class="lineNum">     535</span>              :       shared_ptr(const weak_ptr&lt;_Tp&gt;&amp; __r, std::nothrow_t) noexcept</span>
<span id="L536"><span class="lineNum">     536</span>              :       : __shared_ptr&lt;_Tp&gt;(__r, std::nothrow) { }</span>
<span id="L537"><span class="lineNum">     537</span>              : </span>
<span id="L538"><span class="lineNum">     538</span>              :       friend class weak_ptr&lt;_Tp&gt;;</span>
<span id="L539"><span class="lineNum">     539</span>              :     };</span>
<span id="L540"><span class="lineNum">     540</span>              : </span>
<span id="L541"><span class="lineNum">     541</span>              : #if __cpp_deduction_guides &gt;= 201606</span>
<span id="L542"><span class="lineNum">     542</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L543"><span class="lineNum">     543</span>              :     shared_ptr(weak_ptr&lt;_Tp&gt;) -&gt;  shared_ptr&lt;_Tp&gt;;</span>
<span id="L544"><span class="lineNum">     544</span>              :   template&lt;typename _Tp, typename _Del&gt;</span>
<span id="L545"><span class="lineNum">     545</span>              :     shared_ptr(unique_ptr&lt;_Tp, _Del&gt;) -&gt;  shared_ptr&lt;_Tp&gt;;</span>
<span id="L546"><span class="lineNum">     546</span>              : #endif</span>
<span id="L547"><span class="lineNum">     547</span>              : </span>
<span id="L548"><span class="lineNum">     548</span>              :   // 20.7.2.2.7 shared_ptr comparisons</span>
<span id="L549"><span class="lineNum">     549</span>              : </span>
<span id="L550"><span class="lineNum">     550</span>              :   /// @relates shared_ptr @{</span>
<span id="L551"><span class="lineNum">     551</span>              : </span>
<span id="L552"><span class="lineNum">     552</span>              :   /// Equality operator for shared_ptr objects, compares the stored pointers</span>
<span id="L553"><span class="lineNum">     553</span>              :   template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L554"><span class="lineNum">     554</span>              :     _GLIBCXX_NODISCARD inline bool</span>
<span id="L555"><span class="lineNum">     555</span>              :     operator==(const shared_ptr&lt;_Tp&gt;&amp; __a, const shared_ptr&lt;_Up&gt;&amp; __b) noexcept</span>
<span id="L556"><span class="lineNum">     556</span>              :     { return __a.get() == __b.get(); }</span>
<span id="L557"><span class="lineNum">     557</span>              : </span>
<span id="L558"><span class="lineNum">     558</span>              :   /// shared_ptr comparison with nullptr</span>
<span id="L559"><span class="lineNum">     559</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L560"><span class="lineNum">     560</span>              :     _GLIBCXX_NODISCARD inline bool</span>
<span id="L561"><span class="lineNum">     561</span>              :     operator==(const shared_ptr&lt;_Tp&gt;&amp; __a, nullptr_t) noexcept</span>
<span id="L562"><span class="lineNum">     562</span>              :     { return !__a; }</span>
<span id="L563"><span class="lineNum">     563</span>              : </span>
<span id="L564"><span class="lineNum">     564</span>              : #ifdef __cpp_lib_three_way_comparison</span>
<span id="L565"><span class="lineNum">     565</span>              :   template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L566"><span class="lineNum">     566</span>              :     inline strong_ordering</span>
<span id="L567"><span class="lineNum">     567</span>              :     operator&lt;=&gt;(const shared_ptr&lt;_Tp&gt;&amp; __a,</span>
<span id="L568"><span class="lineNum">     568</span>              :                 const shared_ptr&lt;_Up&gt;&amp; __b) noexcept</span>
<span id="L569"><span class="lineNum">     569</span>              :     { return compare_three_way()(__a.get(), __b.get()); }</span>
<span id="L570"><span class="lineNum">     570</span>              : </span>
<span id="L571"><span class="lineNum">     571</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L572"><span class="lineNum">     572</span>              :     inline strong_ordering</span>
<span id="L573"><span class="lineNum">     573</span>              :     operator&lt;=&gt;(const shared_ptr&lt;_Tp&gt;&amp; __a, nullptr_t) noexcept</span>
<span id="L574"><span class="lineNum">     574</span>              :     {</span>
<span id="L575"><span class="lineNum">     575</span>              :       using pointer = typename shared_ptr&lt;_Tp&gt;::element_type*;</span>
<span id="L576"><span class="lineNum">     576</span>              :       return compare_three_way()(__a.get(), static_cast&lt;pointer&gt;(nullptr));</span>
<span id="L577"><span class="lineNum">     577</span>              :     }</span>
<span id="L578"><span class="lineNum">     578</span>              : #else</span>
<span id="L579"><span class="lineNum">     579</span>              :   /// shared_ptr comparison with nullptr</span>
<span id="L580"><span class="lineNum">     580</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L581"><span class="lineNum">     581</span>              :     _GLIBCXX_NODISCARD inline bool</span>
<span id="L582"><span class="lineNum">     582</span>              :     operator==(nullptr_t, const shared_ptr&lt;_Tp&gt;&amp; __a) noexcept</span>
<span id="L583"><span class="lineNum">     583</span>              :     { return !__a; }</span>
<span id="L584"><span class="lineNum">     584</span>              : </span>
<span id="L585"><span class="lineNum">     585</span>              :   /// Inequality operator for shared_ptr objects, compares the stored pointers</span>
<span id="L586"><span class="lineNum">     586</span>              :   template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L587"><span class="lineNum">     587</span>              :     _GLIBCXX_NODISCARD inline bool</span>
<span id="L588"><span class="lineNum">     588</span>              :     operator!=(const shared_ptr&lt;_Tp&gt;&amp; __a, const shared_ptr&lt;_Up&gt;&amp; __b) noexcept</span>
<span id="L589"><span class="lineNum">     589</span>              :     { return __a.get() != __b.get(); }</span>
<span id="L590"><span class="lineNum">     590</span>              : </span>
<span id="L591"><span class="lineNum">     591</span>              :   /// shared_ptr comparison with nullptr</span>
<span id="L592"><span class="lineNum">     592</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L593"><span class="lineNum">     593</span>              :     _GLIBCXX_NODISCARD inline bool</span>
<span id="L594"><span class="lineNum">     594</span>              :     operator!=(const shared_ptr&lt;_Tp&gt;&amp; __a, nullptr_t) noexcept</span>
<span id="L595"><span class="lineNum">     595</span>              :     { return (bool)__a; }</span>
<span id="L596"><span class="lineNum">     596</span>              : </span>
<span id="L597"><span class="lineNum">     597</span>              :   /// shared_ptr comparison with nullptr</span>
<span id="L598"><span class="lineNum">     598</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L599"><span class="lineNum">     599</span>              :     _GLIBCXX_NODISCARD inline bool</span>
<span id="L600"><span class="lineNum">     600</span>              :     operator!=(nullptr_t, const shared_ptr&lt;_Tp&gt;&amp; __a) noexcept</span>
<span id="L601"><span class="lineNum">     601</span>              :     { return (bool)__a; }</span>
<span id="L602"><span class="lineNum">     602</span>              : </span>
<span id="L603"><span class="lineNum">     603</span>              :   /// Relational operator for shared_ptr objects, compares the stored pointers</span>
<span id="L604"><span class="lineNum">     604</span>              :   template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L605"><span class="lineNum">     605</span>              :     _GLIBCXX_NODISCARD inline bool</span>
<span id="L606"><span class="lineNum">     606</span>              :     operator&lt;(const shared_ptr&lt;_Tp&gt;&amp; __a, const shared_ptr&lt;_Up&gt;&amp; __b) noexcept</span>
<span id="L607"><span class="lineNum">     607</span>              :     {</span>
<span id="L608"><span class="lineNum">     608</span>              :       using _Tp_elt = typename shared_ptr&lt;_Tp&gt;::element_type;</span>
<span id="L609"><span class="lineNum">     609</span>              :       using _Up_elt = typename shared_ptr&lt;_Up&gt;::element_type;</span>
<span id="L610"><span class="lineNum">     610</span>              :       using _Vp = typename common_type&lt;_Tp_elt*, _Up_elt*&gt;::type;</span>
<span id="L611"><span class="lineNum">     611</span>              :       return less&lt;_Vp&gt;()(__a.get(), __b.get());</span>
<span id="L612"><span class="lineNum">     612</span>              :     }</span>
<span id="L613"><span class="lineNum">     613</span>              : </span>
<span id="L614"><span class="lineNum">     614</span>              :   /// shared_ptr comparison with nullptr</span>
<span id="L615"><span class="lineNum">     615</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L616"><span class="lineNum">     616</span>              :     _GLIBCXX_NODISCARD inline bool</span>
<span id="L617"><span class="lineNum">     617</span>              :     operator&lt;(const shared_ptr&lt;_Tp&gt;&amp; __a, nullptr_t) noexcept</span>
<span id="L618"><span class="lineNum">     618</span>              :     {</span>
<span id="L619"><span class="lineNum">     619</span>              :       using _Tp_elt = typename shared_ptr&lt;_Tp&gt;::element_type;</span>
<span id="L620"><span class="lineNum">     620</span>              :       return less&lt;_Tp_elt*&gt;()(__a.get(), nullptr);</span>
<span id="L621"><span class="lineNum">     621</span>              :     }</span>
<span id="L622"><span class="lineNum">     622</span>              : </span>
<span id="L623"><span class="lineNum">     623</span>              :   /// shared_ptr comparison with nullptr</span>
<span id="L624"><span class="lineNum">     624</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L625"><span class="lineNum">     625</span>              :     _GLIBCXX_NODISCARD inline bool</span>
<span id="L626"><span class="lineNum">     626</span>              :     operator&lt;(nullptr_t, const shared_ptr&lt;_Tp&gt;&amp; __a) noexcept</span>
<span id="L627"><span class="lineNum">     627</span>              :     {</span>
<span id="L628"><span class="lineNum">     628</span>              :       using _Tp_elt = typename shared_ptr&lt;_Tp&gt;::element_type;</span>
<span id="L629"><span class="lineNum">     629</span>              :       return less&lt;_Tp_elt*&gt;()(nullptr, __a.get());</span>
<span id="L630"><span class="lineNum">     630</span>              :     }</span>
<span id="L631"><span class="lineNum">     631</span>              : </span>
<span id="L632"><span class="lineNum">     632</span>              :   /// Relational operator for shared_ptr objects, compares the stored pointers</span>
<span id="L633"><span class="lineNum">     633</span>              :   template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L634"><span class="lineNum">     634</span>              :     _GLIBCXX_NODISCARD inline bool</span>
<span id="L635"><span class="lineNum">     635</span>              :     operator&lt;=(const shared_ptr&lt;_Tp&gt;&amp; __a, const shared_ptr&lt;_Up&gt;&amp; __b) noexcept</span>
<span id="L636"><span class="lineNum">     636</span>              :     { return !(__b &lt; __a); }</span>
<span id="L637"><span class="lineNum">     637</span>              : </span>
<span id="L638"><span class="lineNum">     638</span>              :   /// shared_ptr comparison with nullptr</span>
<span id="L639"><span class="lineNum">     639</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L640"><span class="lineNum">     640</span>              :     _GLIBCXX_NODISCARD inline bool</span>
<span id="L641"><span class="lineNum">     641</span>              :     operator&lt;=(const shared_ptr&lt;_Tp&gt;&amp; __a, nullptr_t) noexcept</span>
<span id="L642"><span class="lineNum">     642</span>              :     { return !(nullptr &lt; __a); }</span>
<span id="L643"><span class="lineNum">     643</span>              : </span>
<span id="L644"><span class="lineNum">     644</span>              :   /// shared_ptr comparison with nullptr</span>
<span id="L645"><span class="lineNum">     645</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L646"><span class="lineNum">     646</span>              :     _GLIBCXX_NODISCARD inline bool</span>
<span id="L647"><span class="lineNum">     647</span>              :     operator&lt;=(nullptr_t, const shared_ptr&lt;_Tp&gt;&amp; __a) noexcept</span>
<span id="L648"><span class="lineNum">     648</span>              :     { return !(__a &lt; nullptr); }</span>
<span id="L649"><span class="lineNum">     649</span>              : </span>
<span id="L650"><span class="lineNum">     650</span>              :   /// Relational operator for shared_ptr objects, compares the stored pointers</span>
<span id="L651"><span class="lineNum">     651</span>              :   template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L652"><span class="lineNum">     652</span>              :     _GLIBCXX_NODISCARD inline bool</span>
<span id="L653"><span class="lineNum">     653</span>              :     operator&gt;(const shared_ptr&lt;_Tp&gt;&amp; __a, const shared_ptr&lt;_Up&gt;&amp; __b) noexcept</span>
<span id="L654"><span class="lineNum">     654</span>              :     { return (__b &lt; __a); }</span>
<span id="L655"><span class="lineNum">     655</span>              : </span>
<span id="L656"><span class="lineNum">     656</span>              :   /// shared_ptr comparison with nullptr</span>
<span id="L657"><span class="lineNum">     657</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L658"><span class="lineNum">     658</span>              :     _GLIBCXX_NODISCARD inline bool</span>
<span id="L659"><span class="lineNum">     659</span>              :     operator&gt;(const shared_ptr&lt;_Tp&gt;&amp; __a, nullptr_t) noexcept</span>
<span id="L660"><span class="lineNum">     660</span>              :     { return nullptr &lt; __a; }</span>
<span id="L661"><span class="lineNum">     661</span>              : </span>
<span id="L662"><span class="lineNum">     662</span>              :   /// shared_ptr comparison with nullptr</span>
<span id="L663"><span class="lineNum">     663</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L664"><span class="lineNum">     664</span>              :     _GLIBCXX_NODISCARD inline bool</span>
<span id="L665"><span class="lineNum">     665</span>              :     operator&gt;(nullptr_t, const shared_ptr&lt;_Tp&gt;&amp; __a) noexcept</span>
<span id="L666"><span class="lineNum">     666</span>              :     { return __a &lt; nullptr; }</span>
<span id="L667"><span class="lineNum">     667</span>              : </span>
<span id="L668"><span class="lineNum">     668</span>              :   /// Relational operator for shared_ptr objects, compares the stored pointers</span>
<span id="L669"><span class="lineNum">     669</span>              :   template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L670"><span class="lineNum">     670</span>              :     _GLIBCXX_NODISCARD inline bool</span>
<span id="L671"><span class="lineNum">     671</span>              :     operator&gt;=(const shared_ptr&lt;_Tp&gt;&amp; __a, const shared_ptr&lt;_Up&gt;&amp; __b) noexcept</span>
<span id="L672"><span class="lineNum">     672</span>              :     { return !(__a &lt; __b); }</span>
<span id="L673"><span class="lineNum">     673</span>              : </span>
<span id="L674"><span class="lineNum">     674</span>              :   /// shared_ptr comparison with nullptr</span>
<span id="L675"><span class="lineNum">     675</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L676"><span class="lineNum">     676</span>              :     _GLIBCXX_NODISCARD inline bool</span>
<span id="L677"><span class="lineNum">     677</span>              :     operator&gt;=(const shared_ptr&lt;_Tp&gt;&amp; __a, nullptr_t) noexcept</span>
<span id="L678"><span class="lineNum">     678</span>              :     { return !(__a &lt; nullptr); }</span>
<span id="L679"><span class="lineNum">     679</span>              : </span>
<span id="L680"><span class="lineNum">     680</span>              :   /// shared_ptr comparison with nullptr</span>
<span id="L681"><span class="lineNum">     681</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L682"><span class="lineNum">     682</span>              :     _GLIBCXX_NODISCARD inline bool</span>
<span id="L683"><span class="lineNum">     683</span>              :     operator&gt;=(nullptr_t, const shared_ptr&lt;_Tp&gt;&amp; __a) noexcept</span>
<span id="L684"><span class="lineNum">     684</span>              :     { return !(nullptr &lt; __a); }</span>
<span id="L685"><span class="lineNum">     685</span>              : #endif</span>
<span id="L686"><span class="lineNum">     686</span>              : </span>
<span id="L687"><span class="lineNum">     687</span>              :   // 20.7.2.2.8 shared_ptr specialized algorithms.</span>
<span id="L688"><span class="lineNum">     688</span>              : </span>
<span id="L689"><span class="lineNum">     689</span>              :   /// Swap overload for shared_ptr</span>
<span id="L690"><span class="lineNum">     690</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L691"><span class="lineNum">     691</span>              :     inline void</span>
<span id="L692"><span class="lineNum">     692</span>              :     swap(shared_ptr&lt;_Tp&gt;&amp; __a, shared_ptr&lt;_Tp&gt;&amp; __b) noexcept</span>
<span id="L693"><span class="lineNum">     693</span>              :     { __a.swap(__b); }</span>
<span id="L694"><span class="lineNum">     694</span>              : </span>
<span id="L695"><span class="lineNum">     695</span>              :   // 20.7.2.2.9 shared_ptr casts.</span>
<span id="L696"><span class="lineNum">     696</span>              : </span>
<span id="L697"><span class="lineNum">     697</span>              :   /// Convert type of `shared_ptr`, via `static_cast`</span>
<span id="L698"><span class="lineNum">     698</span>              :   template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L699"><span class="lineNum">     699</span>              :     inline shared_ptr&lt;_Tp&gt;</span>
<span id="L700"><span class="lineNum">     700</span>              :     static_pointer_cast(const shared_ptr&lt;_Up&gt;&amp; __r) noexcept</span>
<span id="L701"><span class="lineNum">     701</span>              :     {</span>
<span id="L702"><span class="lineNum">     702</span>              :       using _Sp = shared_ptr&lt;_Tp&gt;;</span>
<span id="L703"><span class="lineNum">     703</span>              :       return _Sp(__r, static_cast&lt;typename _Sp::element_type*&gt;(__r.get()));</span>
<span id="L704"><span class="lineNum">     704</span>              :     }</span>
<span id="L705"><span class="lineNum">     705</span>              : </span>
<span id="L706"><span class="lineNum">     706</span>              :   /// Convert type of `shared_ptr`, via `const_cast`</span>
<span id="L707"><span class="lineNum">     707</span>              :   template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L708"><span class="lineNum">     708</span>              :     inline shared_ptr&lt;_Tp&gt;</span>
<span id="L709"><span class="lineNum">     709</span>              :     const_pointer_cast(const shared_ptr&lt;_Up&gt;&amp; __r) noexcept</span>
<span id="L710"><span class="lineNum">     710</span>              :     {</span>
<span id="L711"><span class="lineNum">     711</span>              :       using _Sp = shared_ptr&lt;_Tp&gt;;</span>
<span id="L712"><span class="lineNum">     712</span>              :       return _Sp(__r, const_cast&lt;typename _Sp::element_type*&gt;(__r.get()));</span>
<span id="L713"><span class="lineNum">     713</span>              :     }</span>
<span id="L714"><span class="lineNum">     714</span>              : </span>
<span id="L715"><span class="lineNum">     715</span>              :   /// Convert type of `shared_ptr`, via `dynamic_cast`</span>
<span id="L716"><span class="lineNum">     716</span>              :   template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L717"><span class="lineNum">     717</span>              :     inline shared_ptr&lt;_Tp&gt;</span>
<span id="L718"><span class="lineNum">     718</span>              :     dynamic_pointer_cast(const shared_ptr&lt;_Up&gt;&amp; __r) noexcept</span>
<span id="L719"><span class="lineNum">     719</span>              :     {</span>
<span id="L720"><span class="lineNum">     720</span>              :       using _Sp = shared_ptr&lt;_Tp&gt;;</span>
<span id="L721"><span class="lineNum">     721</span>              :       if (auto* __p = dynamic_cast&lt;typename _Sp::element_type*&gt;(__r.get()))</span>
<span id="L722"><span class="lineNum">     722</span>              :         return _Sp(__r, __p);</span>
<span id="L723"><span class="lineNum">     723</span>              :       return _Sp();</span>
<span id="L724"><span class="lineNum">     724</span>              :     }</span>
<span id="L725"><span class="lineNum">     725</span>              : </span>
<span id="L726"><span class="lineNum">     726</span>              : #if __cplusplus &gt;= 201703L</span>
<span id="L727"><span class="lineNum">     727</span>              :   /// Convert type of `shared_ptr`, via `reinterpret_cast`</span>
<span id="L728"><span class="lineNum">     728</span>              :   /// @since C++17</span>
<span id="L729"><span class="lineNum">     729</span>              :   template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L730"><span class="lineNum">     730</span>              :     inline shared_ptr&lt;_Tp&gt;</span>
<span id="L731"><span class="lineNum">     731</span>              :     reinterpret_pointer_cast(const shared_ptr&lt;_Up&gt;&amp; __r) noexcept</span>
<span id="L732"><span class="lineNum">     732</span>              :     {</span>
<span id="L733"><span class="lineNum">     733</span>              :       using _Sp = shared_ptr&lt;_Tp&gt;;</span>
<span id="L734"><span class="lineNum">     734</span>              :       return _Sp(__r, reinterpret_cast&lt;typename _Sp::element_type*&gt;(__r.get()));</span>
<span id="L735"><span class="lineNum">     735</span>              :     }</span>
<span id="L736"><span class="lineNum">     736</span>              : </span>
<span id="L737"><span class="lineNum">     737</span>              : #if __cplusplus &gt; 201703L</span>
<span id="L738"><span class="lineNum">     738</span>              :   // _GLIBCXX_RESOLVE_LIB_DEFECTS</span>
<span id="L739"><span class="lineNum">     739</span>              :   // 2996. Missing rvalue overloads for shared_ptr operations</span>
<span id="L740"><span class="lineNum">     740</span>              : </span>
<span id="L741"><span class="lineNum">     741</span>              :   /// Convert type of `shared_ptr` rvalue, via `static_cast`</span>
<span id="L742"><span class="lineNum">     742</span>              :   /// @since C++20</span>
<span id="L743"><span class="lineNum">     743</span>              :   template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L744"><span class="lineNum">     744</span>              :     inline shared_ptr&lt;_Tp&gt;</span>
<span id="L745"><span class="lineNum">     745</span>              :     static_pointer_cast(shared_ptr&lt;_Up&gt;&amp;&amp; __r) noexcept</span>
<span id="L746"><span class="lineNum">     746</span>              :     {</span>
<span id="L747"><span class="lineNum">     747</span>              :       using _Sp = shared_ptr&lt;_Tp&gt;;</span>
<span id="L748"><span class="lineNum">     748</span>              :       return _Sp(std::move(__r),</span>
<span id="L749"><span class="lineNum">     749</span>              :                  static_cast&lt;typename _Sp::element_type*&gt;(__r.get()));</span>
<span id="L750"><span class="lineNum">     750</span>              :     }</span>
<span id="L751"><span class="lineNum">     751</span>              : </span>
<span id="L752"><span class="lineNum">     752</span>              :   /// Convert type of `shared_ptr` rvalue, via `const_cast`</span>
<span id="L753"><span class="lineNum">     753</span>              :   /// @since C++20</span>
<span id="L754"><span class="lineNum">     754</span>              :   template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L755"><span class="lineNum">     755</span>              :     inline shared_ptr&lt;_Tp&gt;</span>
<span id="L756"><span class="lineNum">     756</span>              :     const_pointer_cast(shared_ptr&lt;_Up&gt;&amp;&amp; __r) noexcept</span>
<span id="L757"><span class="lineNum">     757</span>              :     {</span>
<span id="L758"><span class="lineNum">     758</span>              :       using _Sp = shared_ptr&lt;_Tp&gt;;</span>
<span id="L759"><span class="lineNum">     759</span>              :       return _Sp(std::move(__r),</span>
<span id="L760"><span class="lineNum">     760</span>              :                  const_cast&lt;typename _Sp::element_type*&gt;(__r.get()));</span>
<span id="L761"><span class="lineNum">     761</span>              :     }</span>
<span id="L762"><span class="lineNum">     762</span>              : </span>
<span id="L763"><span class="lineNum">     763</span>              :   /// Convert type of `shared_ptr` rvalue, via `dynamic_cast`</span>
<span id="L764"><span class="lineNum">     764</span>              :   /// @since C++20</span>
<span id="L765"><span class="lineNum">     765</span>              :   template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L766"><span class="lineNum">     766</span>              :     inline shared_ptr&lt;_Tp&gt;</span>
<span id="L767"><span class="lineNum">     767</span>              :     dynamic_pointer_cast(shared_ptr&lt;_Up&gt;&amp;&amp; __r) noexcept</span>
<span id="L768"><span class="lineNum">     768</span>              :     {</span>
<span id="L769"><span class="lineNum">     769</span>              :       using _Sp = shared_ptr&lt;_Tp&gt;;</span>
<span id="L770"><span class="lineNum">     770</span>              :       if (auto* __p = dynamic_cast&lt;typename _Sp::element_type*&gt;(__r.get()))</span>
<span id="L771"><span class="lineNum">     771</span>              :         return _Sp(std::move(__r), __p);</span>
<span id="L772"><span class="lineNum">     772</span>              :       return _Sp();</span>
<span id="L773"><span class="lineNum">     773</span>              :     }</span>
<span id="L774"><span class="lineNum">     774</span>              : </span>
<span id="L775"><span class="lineNum">     775</span>              :   /// Convert type of `shared_ptr` rvalue, via `reinterpret_cast`</span>
<span id="L776"><span class="lineNum">     776</span>              :   /// @since C++20</span>
<span id="L777"><span class="lineNum">     777</span>              :   template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L778"><span class="lineNum">     778</span>              :     inline shared_ptr&lt;_Tp&gt;</span>
<span id="L779"><span class="lineNum">     779</span>              :     reinterpret_pointer_cast(shared_ptr&lt;_Up&gt;&amp;&amp; __r) noexcept</span>
<span id="L780"><span class="lineNum">     780</span>              :     {</span>
<span id="L781"><span class="lineNum">     781</span>              :       using _Sp = shared_ptr&lt;_Tp&gt;;</span>
<span id="L782"><span class="lineNum">     782</span>              :       return _Sp(std::move(__r),</span>
<span id="L783"><span class="lineNum">     783</span>              :                  reinterpret_cast&lt;typename _Sp::element_type*&gt;(__r.get()));</span>
<span id="L784"><span class="lineNum">     784</span>              :     }</span>
<span id="L785"><span class="lineNum">     785</span>              : #endif // C++20</span>
<span id="L786"><span class="lineNum">     786</span>              : #endif // C++17</span>
<span id="L787"><span class="lineNum">     787</span>              : </span>
<span id="L788"><span class="lineNum">     788</span>              :   /// @}</span>
<span id="L789"><span class="lineNum">     789</span>              : </span>
<span id="L790"><span class="lineNum">     790</span>              :   /**</span>
<span id="L791"><span class="lineNum">     791</span>              :    * @brief  A non-owning observer for a pointer owned by a shared_ptr</span>
<span id="L792"><span class="lineNum">     792</span>              :    * @headerfile memory</span>
<span id="L793"><span class="lineNum">     793</span>              :    * @since C++11</span>
<span id="L794"><span class="lineNum">     794</span>              :    *</span>
<span id="L795"><span class="lineNum">     795</span>              :    * A weak_ptr provides a safe alternative to a raw pointer when you want</span>
<span id="L796"><span class="lineNum">     796</span>              :    * a non-owning reference to an object that is managed by a shared_ptr.</span>
<span id="L797"><span class="lineNum">     797</span>              :    *</span>
<span id="L798"><span class="lineNum">     798</span>              :    * Unlike a raw pointer, a weak_ptr can be converted to a new shared_ptr</span>
<span id="L799"><span class="lineNum">     799</span>              :    * that shares ownership with every other shared_ptr that already owns</span>
<span id="L800"><span class="lineNum">     800</span>              :    * the pointer. In other words you can upgrade from a non-owning &quot;weak&quot;</span>
<span id="L801"><span class="lineNum">     801</span>              :    * reference to an owning shared_ptr, without having access to any of</span>
<span id="L802"><span class="lineNum">     802</span>              :    * the existing shared_ptr objects.</span>
<span id="L803"><span class="lineNum">     803</span>              :    *</span>
<span id="L804"><span class="lineNum">     804</span>              :    * Also unlike a raw pointer, a weak_ptr does not become &quot;dangling&quot; after</span>
<span id="L805"><span class="lineNum">     805</span>              :    * the object it points to has been destroyed. Instead, a weak_ptr</span>
<span id="L806"><span class="lineNum">     806</span>              :    * becomes _expired_ and can no longer be converted to a shared_ptr that</span>
<span id="L807"><span class="lineNum">     807</span>              :    * owns the freed pointer, so you cannot accidentally access the pointed-to</span>
<span id="L808"><span class="lineNum">     808</span>              :    * object after it has been destroyed.</span>
<span id="L809"><span class="lineNum">     809</span>              :    */</span>
<span id="L810"><span class="lineNum">     810</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L811"><span class="lineNum">     811</span>              :     class weak_ptr : public __weak_ptr&lt;_Tp&gt;</span>
<span id="L812"><span class="lineNum">     812</span>              :     {</span>
<span id="L813"><span class="lineNum">     813</span>              :       template&lt;typename _Arg&gt;</span>
<span id="L814"><span class="lineNum">     814</span>              :         using _Constructible = typename enable_if&lt;</span>
<span id="L815"><span class="lineNum">     815</span>              :           is_constructible&lt;__weak_ptr&lt;_Tp&gt;, _Arg&gt;::value</span>
<span id="L816"><span class="lineNum">     816</span>              :         &gt;::type;</span>
<span id="L817"><span class="lineNum">     817</span>              : </span>
<span id="L818"><span class="lineNum">     818</span>              :       template&lt;typename _Arg&gt;</span>
<span id="L819"><span class="lineNum">     819</span>              :         using _Assignable = typename enable_if&lt;</span>
<span id="L820"><span class="lineNum">     820</span>              :           is_assignable&lt;__weak_ptr&lt;_Tp&gt;&amp;, _Arg&gt;::value, weak_ptr&amp;</span>
<span id="L821"><span class="lineNum">     821</span>              :         &gt;::type;</span>
<span id="L822"><span class="lineNum">     822</span>              : </span>
<span id="L823"><span class="lineNum">     823</span>              :     public:</span>
<span id="L824"><span class="lineNum">     824</span>              :       constexpr weak_ptr() noexcept = default;</span>
<span id="L825"><span class="lineNum">     825</span>              : </span>
<span id="L826"><span class="lineNum">     826</span>              :       template&lt;typename _Yp,</span>
<span id="L827"><span class="lineNum">     827</span>              :                typename = _Constructible&lt;const shared_ptr&lt;_Yp&gt;&amp;&gt;&gt;</span>
<span id="L828"><span class="lineNum">     828</span>              :         weak_ptr(const shared_ptr&lt;_Yp&gt;&amp; __r) noexcept</span>
<span id="L829"><span class="lineNum">     829</span>              :         : __weak_ptr&lt;_Tp&gt;(__r) { }</span>
<span id="L830"><span class="lineNum">     830</span>              : </span>
<span id="L831"><span class="lineNum">     831</span>              :       weak_ptr(const weak_ptr&amp;) noexcept = default;</span>
<span id="L832"><span class="lineNum">     832</span>              : </span>
<span id="L833"><span class="lineNum">     833</span>              :       template&lt;typename _Yp, typename = _Constructible&lt;const weak_ptr&lt;_Yp&gt;&amp;&gt;&gt;</span>
<span id="L834"><span class="lineNum">     834</span>              :         weak_ptr(const weak_ptr&lt;_Yp&gt;&amp; __r) noexcept</span>
<span id="L835"><span class="lineNum">     835</span>              :         : __weak_ptr&lt;_Tp&gt;(__r) { }</span>
<span id="L836"><span class="lineNum">     836</span>              : </span>
<span id="L837"><span class="lineNum">     837</span>              :       weak_ptr(weak_ptr&amp;&amp;) noexcept = default;</span>
<span id="L838"><span class="lineNum">     838</span>              : </span>
<span id="L839"><span class="lineNum">     839</span>              :       template&lt;typename _Yp, typename = _Constructible&lt;weak_ptr&lt;_Yp&gt;&gt;&gt;</span>
<span id="L840"><span class="lineNum">     840</span>              :         weak_ptr(weak_ptr&lt;_Yp&gt;&amp;&amp; __r) noexcept</span>
<span id="L841"><span class="lineNum">     841</span>              :         : __weak_ptr&lt;_Tp&gt;(std::move(__r)) { }</span>
<span id="L842"><span class="lineNum">     842</span>              : </span>
<span id="L843"><span class="lineNum">     843</span>              :       weak_ptr&amp;</span>
<span id="L844"><span class="lineNum">     844</span>              :       operator=(const weak_ptr&amp; __r) noexcept = default;</span>
<span id="L845"><span class="lineNum">     845</span>              : </span>
<span id="L846"><span class="lineNum">     846</span>              :       template&lt;typename _Yp&gt;</span>
<span id="L847"><span class="lineNum">     847</span>              :         _Assignable&lt;const weak_ptr&lt;_Yp&gt;&amp;&gt;</span>
<span id="L848"><span class="lineNum">     848</span>              :         operator=(const weak_ptr&lt;_Yp&gt;&amp; __r) noexcept</span>
<span id="L849"><span class="lineNum">     849</span>              :         {</span>
<span id="L850"><span class="lineNum">     850</span>              :           this-&gt;__weak_ptr&lt;_Tp&gt;::operator=(__r);</span>
<span id="L851"><span class="lineNum">     851</span>              :           return *this;</span>
<span id="L852"><span class="lineNum">     852</span>              :         }</span>
<span id="L853"><span class="lineNum">     853</span>              : </span>
<span id="L854"><span class="lineNum">     854</span>              :       template&lt;typename _Yp&gt;</span>
<span id="L855"><span class="lineNum">     855</span>              :         _Assignable&lt;const shared_ptr&lt;_Yp&gt;&amp;&gt;</span>
<span id="L856"><span class="lineNum">     856</span>              :         operator=(const shared_ptr&lt;_Yp&gt;&amp; __r) noexcept</span>
<span id="L857"><span class="lineNum">     857</span>              :         {</span>
<span id="L858"><span class="lineNum">     858</span>              :           this-&gt;__weak_ptr&lt;_Tp&gt;::operator=(__r);</span>
<span id="L859"><span class="lineNum">     859</span>              :           return *this;</span>
<span id="L860"><span class="lineNum">     860</span>              :         }</span>
<span id="L861"><span class="lineNum">     861</span>              : </span>
<span id="L862"><span class="lineNum">     862</span>              :       weak_ptr&amp;</span>
<span id="L863"><span class="lineNum">     863</span>              :       operator=(weak_ptr&amp;&amp; __r) noexcept = default;</span>
<span id="L864"><span class="lineNum">     864</span>              : </span>
<span id="L865"><span class="lineNum">     865</span>              :       template&lt;typename _Yp&gt;</span>
<span id="L866"><span class="lineNum">     866</span>              :         _Assignable&lt;weak_ptr&lt;_Yp&gt;&gt;</span>
<span id="L867"><span class="lineNum">     867</span>              :         operator=(weak_ptr&lt;_Yp&gt;&amp;&amp; __r) noexcept</span>
<span id="L868"><span class="lineNum">     868</span>              :         {</span>
<span id="L869"><span class="lineNum">     869</span>              :           this-&gt;__weak_ptr&lt;_Tp&gt;::operator=(std::move(__r));</span>
<span id="L870"><span class="lineNum">     870</span>              :           return *this;</span>
<span id="L871"><span class="lineNum">     871</span>              :         }</span>
<span id="L872"><span class="lineNum">     872</span>              : </span>
<span id="L873"><span class="lineNum">     873</span>              :       shared_ptr&lt;_Tp&gt;</span>
<span id="L874"><span class="lineNum">     874</span>              :       lock() const noexcept</span>
<span id="L875"><span class="lineNum">     875</span>              :       { return shared_ptr&lt;_Tp&gt;(*this, std::nothrow); }</span>
<span id="L876"><span class="lineNum">     876</span>              :     };</span>
<span id="L877"><span class="lineNum">     877</span>              : </span>
<span id="L878"><span class="lineNum">     878</span>              : #if __cpp_deduction_guides &gt;= 201606</span>
<span id="L879"><span class="lineNum">     879</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L880"><span class="lineNum">     880</span>              :     weak_ptr(shared_ptr&lt;_Tp&gt;) -&gt;  weak_ptr&lt;_Tp&gt;;</span>
<span id="L881"><span class="lineNum">     881</span>              : #endif</span>
<span id="L882"><span class="lineNum">     882</span>              : </span>
<span id="L883"><span class="lineNum">     883</span>              :   // 20.7.2.3.6 weak_ptr specialized algorithms.</span>
<span id="L884"><span class="lineNum">     884</span>              :   /// Swap overload for weak_ptr</span>
<span id="L885"><span class="lineNum">     885</span>              :   /// @relates weak_ptr</span>
<span id="L886"><span class="lineNum">     886</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L887"><span class="lineNum">     887</span>              :     inline void</span>
<span id="L888"><span class="lineNum">     888</span>              :     swap(weak_ptr&lt;_Tp&gt;&amp; __a, weak_ptr&lt;_Tp&gt;&amp; __b) noexcept</span>
<span id="L889"><span class="lineNum">     889</span>              :     { __a.swap(__b); }</span>
<span id="L890"><span class="lineNum">     890</span>              : </span>
<span id="L891"><span class="lineNum">     891</span>              : </span>
<span id="L892"><span class="lineNum">     892</span>              :   /// Primary template owner_less</span>
<span id="L893"><span class="lineNum">     893</span>              :   template&lt;typename _Tp = void&gt;</span>
<span id="L894"><span class="lineNum">     894</span>              :     struct owner_less;</span>
<span id="L895"><span class="lineNum">     895</span>              : </span>
<span id="L896"><span class="lineNum">     896</span>              :   /// Void specialization of owner_less compares either shared_ptr or weak_ptr</span>
<span id="L897"><span class="lineNum">     897</span>              :   template&lt;&gt;</span>
<span id="L898"><span class="lineNum">     898</span>              :     struct owner_less&lt;void&gt; : _Sp_owner_less&lt;void, void&gt;</span>
<span id="L899"><span class="lineNum">     899</span>              :     { };</span>
<span id="L900"><span class="lineNum">     900</span>              : </span>
<span id="L901"><span class="lineNum">     901</span>              :   /// Partial specialization of owner_less for shared_ptr.</span>
<span id="L902"><span class="lineNum">     902</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L903"><span class="lineNum">     903</span>              :     struct owner_less&lt;shared_ptr&lt;_Tp&gt;&gt;</span>
<span id="L904"><span class="lineNum">     904</span>              :     : public _Sp_owner_less&lt;shared_ptr&lt;_Tp&gt;, weak_ptr&lt;_Tp&gt;&gt;</span>
<span id="L905"><span class="lineNum">     905</span>              :     { };</span>
<span id="L906"><span class="lineNum">     906</span>              : </span>
<span id="L907"><span class="lineNum">     907</span>              :   /// Partial specialization of owner_less for weak_ptr.</span>
<span id="L908"><span class="lineNum">     908</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L909"><span class="lineNum">     909</span>              :     struct owner_less&lt;weak_ptr&lt;_Tp&gt;&gt;</span>
<span id="L910"><span class="lineNum">     910</span>              :     : public _Sp_owner_less&lt;weak_ptr&lt;_Tp&gt;, shared_ptr&lt;_Tp&gt;&gt;</span>
<span id="L911"><span class="lineNum">     911</span>              :     { };</span>
<span id="L912"><span class="lineNum">     912</span>              : </span>
<span id="L913"><span class="lineNum">     913</span>              :   /**</span>
<span id="L914"><span class="lineNum">     914</span>              :    * @brief Base class allowing use of the member function `shared_from_this`.</span>
<span id="L915"><span class="lineNum">     915</span>              :    * @headerfile memory</span>
<span id="L916"><span class="lineNum">     916</span>              :    * @since C++11</span>
<span id="L917"><span class="lineNum">     917</span>              :    */</span>
<span id="L918"><span class="lineNum">     918</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L919"><span class="lineNum">     919</span>              :     class enable_shared_from_this</span>
<span id="L920"><span class="lineNum">     920</span>              :     {</span>
<span id="L921"><span class="lineNum">     921</span>              :     protected:</span>
<span id="L922"><span class="lineNum">     922</span>              :       constexpr enable_shared_from_this() noexcept { }</span>
<span id="L923"><span class="lineNum">     923</span>              : </span>
<span id="L924"><span class="lineNum">     924</span>              :       enable_shared_from_this(const enable_shared_from_this&amp;) noexcept { }</span>
<span id="L925"><span class="lineNum">     925</span>              : </span>
<span id="L926"><span class="lineNum">     926</span>              :       enable_shared_from_this&amp;</span>
<span id="L927"><span class="lineNum">     927</span>              :       operator=(const enable_shared_from_this&amp;) noexcept</span>
<span id="L928"><span class="lineNum">     928</span>              :       { return *this; }</span>
<span id="L929"><span class="lineNum">     929</span>              : </span>
<span id="L930"><span class="lineNum">     930</span>              :       ~enable_shared_from_this() { }</span>
<span id="L931"><span class="lineNum">     931</span>              : </span>
<span id="L932"><span class="lineNum">     932</span>              :     public:</span>
<span id="L933"><span class="lineNum">     933</span>              :       shared_ptr&lt;_Tp&gt;</span>
<span id="L934"><span class="lineNum">     934</span>              :       shared_from_this()</span>
<span id="L935"><span class="lineNum">     935</span>              :       { return shared_ptr&lt;_Tp&gt;(this-&gt;_M_weak_this); }</span>
<span id="L936"><span class="lineNum">     936</span>              : </span>
<span id="L937"><span class="lineNum">     937</span>              :       shared_ptr&lt;const _Tp&gt;</span>
<span id="L938"><span class="lineNum">     938</span>              :       shared_from_this() const</span>
<span id="L939"><span class="lineNum">     939</span>              :       { return shared_ptr&lt;const _Tp&gt;(this-&gt;_M_weak_this); }</span>
<span id="L940"><span class="lineNum">     940</span>              : </span>
<span id="L941"><span class="lineNum">     941</span>              : #if __cplusplus &gt; 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11</span>
<span id="L942"><span class="lineNum">     942</span>              : #define __cpp_lib_enable_shared_from_this 201603L</span>
<span id="L943"><span class="lineNum">     943</span>              :       /** @{</span>
<span id="L944"><span class="lineNum">     944</span>              :        * Get a `weak_ptr` referring to the object that has `*this` as its base.</span>
<span id="L945"><span class="lineNum">     945</span>              :        * @since C++17</span>
<span id="L946"><span class="lineNum">     946</span>              :        */</span>
<span id="L947"><span class="lineNum">     947</span>              :       weak_ptr&lt;_Tp&gt;</span>
<span id="L948"><span class="lineNum">     948</span>              :       weak_from_this() noexcept</span>
<span id="L949"><span class="lineNum">     949</span>              :       { return this-&gt;_M_weak_this; }</span>
<span id="L950"><span class="lineNum">     950</span>              : </span>
<span id="L951"><span class="lineNum">     951</span>              :       weak_ptr&lt;const _Tp&gt;</span>
<span id="L952"><span class="lineNum">     952</span>              :       weak_from_this() const noexcept</span>
<span id="L953"><span class="lineNum">     953</span>              :       { return this-&gt;_M_weak_this; }</span>
<span id="L954"><span class="lineNum">     954</span>              :       /// @}</span>
<span id="L955"><span class="lineNum">     955</span>              : #endif</span>
<span id="L956"><span class="lineNum">     956</span>              : </span>
<span id="L957"><span class="lineNum">     957</span>              :     private:</span>
<span id="L958"><span class="lineNum">     958</span>              :       template&lt;typename _Tp1&gt;</span>
<span id="L959"><span class="lineNum">     959</span>              :         void</span>
<span id="L960"><span class="lineNum">     960</span>              :         _M_weak_assign(_Tp1* __p, const __shared_count&lt;&gt;&amp; __n) const noexcept</span>
<span id="L961"><span class="lineNum">     961</span>              :         { _M_weak_this._M_assign(__p, __n); }</span>
<span id="L962"><span class="lineNum">     962</span>              : </span>
<span id="L963"><span class="lineNum">     963</span>              :       // Found by ADL when this is an associated class.</span>
<span id="L964"><span class="lineNum">     964</span>              :       friend const enable_shared_from_this*</span>
<span id="L965"><span class="lineNum">     965</span>              :       __enable_shared_from_this_base(const __shared_count&lt;&gt;&amp;,</span>
<span id="L966"><span class="lineNum">     966</span>              :                                      const enable_shared_from_this* __p)</span>
<span id="L967"><span class="lineNum">     967</span>              :       { return __p; }</span>
<span id="L968"><span class="lineNum">     968</span>              : </span>
<span id="L969"><span class="lineNum">     969</span>              :       template&lt;typename, _Lock_policy&gt;</span>
<span id="L970"><span class="lineNum">     970</span>              :         friend class __shared_ptr;</span>
<span id="L971"><span class="lineNum">     971</span>              : </span>
<span id="L972"><span class="lineNum">     972</span>              :       mutable weak_ptr&lt;_Tp&gt;  _M_weak_this;</span>
<span id="L973"><span class="lineNum">     973</span>              :     };</span>
<span id="L974"><span class="lineNum">     974</span>              : </span>
<span id="L975"><span class="lineNum">     975</span>              :   /// @relates shared_ptr @{</span>
<span id="L976"><span class="lineNum">     976</span>              : </span>
<span id="L977"><span class="lineNum">     977</span>              :   /**</span>
<span id="L978"><span class="lineNum">     978</span>              :    *  @brief  Create an object that is owned by a shared_ptr.</span>
<span id="L979"><span class="lineNum">     979</span>              :    *  @param  __a     An allocator.</span>
<span id="L980"><span class="lineNum">     980</span>              :    *  @param  __args  Arguments for the @a _Tp object's constructor.</span>
<span id="L981"><span class="lineNum">     981</span>              :    *  @return A shared_ptr that owns the newly created object.</span>
<span id="L982"><span class="lineNum">     982</span>              :    *  @throw  An exception thrown from @a _Alloc::allocate or from the</span>
<span id="L983"><span class="lineNum">     983</span>              :    *          constructor of @a _Tp.</span>
<span id="L984"><span class="lineNum">     984</span>              :    *</span>
<span id="L985"><span class="lineNum">     985</span>              :    *  A copy of @a __a will be used to allocate memory for the shared_ptr</span>
<span id="L986"><span class="lineNum">     986</span>              :    *  and the new object.</span>
<span id="L987"><span class="lineNum">     987</span>              :    */</span>
<span id="L988"><span class="lineNum">     988</span>              :   template&lt;typename _Tp, typename _Alloc, typename... _Args&gt;</span>
<span id="L989"><span class="lineNum">     989</span>              :     inline shared_ptr&lt;_NonArray&lt;_Tp&gt;&gt;</span>
<span id="L990"><span class="lineNum">     990</span>              :     allocate_shared(const _Alloc&amp; __a, _Args&amp;&amp;... __args)</span>
<span id="L991"><span class="lineNum">     991</span>              :     {</span>
<span id="L992"><span class="lineNum">     992</span>              :       return shared_ptr&lt;_Tp&gt;(_Sp_alloc_shared_tag&lt;_Alloc&gt;{__a},</span>
<span id="L993"><span class="lineNum">     993</span>              :                              std::forward&lt;_Args&gt;(__args)...);</span>
<span id="L994"><span class="lineNum">     994</span>              :     }</span>
<span id="L995"><span class="lineNum">     995</span>              : </span>
<span id="L996"><span class="lineNum">     996</span>              :   /**</span>
<span id="L997"><span class="lineNum">     997</span>              :    *  @brief  Create an object that is owned by a shared_ptr.</span>
<span id="L998"><span class="lineNum">     998</span>              :    *  @param  __args  Arguments for the @a _Tp object's constructor.</span>
<span id="L999"><span class="lineNum">     999</span>              :    *  @return A shared_ptr that owns the newly created object.</span>
<span id="L1000"><span class="lineNum">    1000</span>              :    *  @throw  std::bad_alloc, or an exception thrown from the</span>
<span id="L1001"><span class="lineNum">    1001</span>              :    *          constructor of @a _Tp.</span>
<span id="L1002"><span class="lineNum">    1002</span>              :    */</span>
<span id="L1003"><span class="lineNum">    1003</span>              :   template&lt;typename _Tp, typename... _Args&gt;</span>
<span id="L1004"><span class="lineNum">    1004</span>              :     inline shared_ptr&lt;_NonArray&lt;_Tp&gt;&gt;</span>
<span id="L1005"><span class="lineNum">    1005</span> <span class="tlaGNC">           2 :     make_shared(_Args&amp;&amp;... __args)</span></span>
<span id="L1006"><span class="lineNum">    1006</span>              :     {</span>
<span id="L1007"><span class="lineNum">    1007</span>              :       using _Alloc = allocator&lt;void&gt;;</span>
<span id="L1008"><span class="lineNum">    1008</span>              :       _Alloc __a;</span>
<span id="L1009"><span class="lineNum">    1009</span>              :       return shared_ptr&lt;_Tp&gt;(_Sp_alloc_shared_tag&lt;_Alloc&gt;{__a},</span>
<span id="L1010"><span class="lineNum">    1010</span> <span class="tlaGNC">           4 :                              std::forward&lt;_Args&gt;(__args)...);</span></span>
<span id="L1011"><span class="lineNum">    1011</span>              :     }</span>
<span id="L1012"><span class="lineNum">    1012</span>              : </span>
<span id="L1013"><span class="lineNum">    1013</span>              : #if __cpp_lib_shared_ptr_arrays &gt;= 201707L</span>
<span id="L1014"><span class="lineNum">    1014</span>              :   /// @cond undocumented</span>
<span id="L1015"><span class="lineNum">    1015</span>              :   template&lt;typename _Tp, typename _Alloc = allocator&lt;void&gt;&gt;</span>
<span id="L1016"><span class="lineNum">    1016</span>              :     auto</span>
<span id="L1017"><span class="lineNum">    1017</span>              :     __make_shared_arr_tag(size_t __n, const _Alloc&amp; __a = _Alloc()) noexcept</span>
<span id="L1018"><span class="lineNum">    1018</span>              :     {</span>
<span id="L1019"><span class="lineNum">    1019</span>              :       using _Up = remove_all_extents_t&lt;_Tp&gt;;</span>
<span id="L1020"><span class="lineNum">    1020</span>              :       using _UpAlloc = __alloc_rebind&lt;_Alloc, _Up&gt;;</span>
<span id="L1021"><span class="lineNum">    1021</span>              :       size_t __s = sizeof(remove_extent_t&lt;_Tp&gt;) / sizeof(_Up);</span>
<span id="L1022"><span class="lineNum">    1022</span>              :       if (__builtin_mul_overflow(__s, __n, &amp;__n))</span>
<span id="L1023"><span class="lineNum">    1023</span>              :         std::__throw_bad_array_new_length();</span>
<span id="L1024"><span class="lineNum">    1024</span>              :       return _Sp_counted_array_base&lt;_UpAlloc&gt;{_UpAlloc(__a), __n};</span>
<span id="L1025"><span class="lineNum">    1025</span>              :     }</span>
<span id="L1026"><span class="lineNum">    1026</span>              :   /// @endcond</span>
<span id="L1027"><span class="lineNum">    1027</span>              : </span>
<span id="L1028"><span class="lineNum">    1028</span>              :   template&lt;typename _Tp, typename _Alloc&gt;</span>
<span id="L1029"><span class="lineNum">    1029</span>              :     inline shared_ptr&lt;_UnboundedArray&lt;_Tp&gt;&gt;</span>
<span id="L1030"><span class="lineNum">    1030</span>              :     allocate_shared(const _Alloc&amp; __a, size_t __n)</span>
<span id="L1031"><span class="lineNum">    1031</span>              :     {</span>
<span id="L1032"><span class="lineNum">    1032</span>              :       return shared_ptr&lt;_Tp&gt;(std::__make_shared_arr_tag&lt;_Tp&gt;(__n, __a));</span>
<span id="L1033"><span class="lineNum">    1033</span>              :     }</span>
<span id="L1034"><span class="lineNum">    1034</span>              : </span>
<span id="L1035"><span class="lineNum">    1035</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L1036"><span class="lineNum">    1036</span>              :     inline shared_ptr&lt;_UnboundedArray&lt;_Tp&gt;&gt;</span>
<span id="L1037"><span class="lineNum">    1037</span>              :     make_shared(size_t __n)</span>
<span id="L1038"><span class="lineNum">    1038</span>              :     {</span>
<span id="L1039"><span class="lineNum">    1039</span>              :       return shared_ptr&lt;_Tp&gt;(std::__make_shared_arr_tag&lt;_Tp&gt;(__n));</span>
<span id="L1040"><span class="lineNum">    1040</span>              :     }</span>
<span id="L1041"><span class="lineNum">    1041</span>              : </span>
<span id="L1042"><span class="lineNum">    1042</span>              :   template&lt;typename _Tp, typename _Alloc&gt;</span>
<span id="L1043"><span class="lineNum">    1043</span>              :     inline shared_ptr&lt;_UnboundedArray&lt;_Tp&gt;&gt;</span>
<span id="L1044"><span class="lineNum">    1044</span>              :     allocate_shared(const _Alloc&amp; __a, size_t __n,</span>
<span id="L1045"><span class="lineNum">    1045</span>              :                     const remove_extent_t&lt;_Tp&gt;&amp; __u)</span>
<span id="L1046"><span class="lineNum">    1046</span>              :     {</span>
<span id="L1047"><span class="lineNum">    1047</span>              :       return shared_ptr&lt;_Tp&gt;(std::__make_shared_arr_tag&lt;_Tp&gt;(__n, __a),</span>
<span id="L1048"><span class="lineNum">    1048</span>              :                              std::__addressof(__u));</span>
<span id="L1049"><span class="lineNum">    1049</span>              :     }</span>
<span id="L1050"><span class="lineNum">    1050</span>              : </span>
<span id="L1051"><span class="lineNum">    1051</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L1052"><span class="lineNum">    1052</span>              :     inline shared_ptr&lt;_UnboundedArray&lt;_Tp&gt;&gt;</span>
<span id="L1053"><span class="lineNum">    1053</span>              :     make_shared(size_t __n, const remove_extent_t&lt;_Tp&gt;&amp; __u)</span>
<span id="L1054"><span class="lineNum">    1054</span>              :     {</span>
<span id="L1055"><span class="lineNum">    1055</span>              :       return shared_ptr&lt;_Tp&gt;(std::__make_shared_arr_tag&lt;_Tp&gt;(__n),</span>
<span id="L1056"><span class="lineNum">    1056</span>              :                              std::__addressof(__u));</span>
<span id="L1057"><span class="lineNum">    1057</span>              :     }</span>
<span id="L1058"><span class="lineNum">    1058</span>              : </span>
<span id="L1059"><span class="lineNum">    1059</span>              :   /// @cond undocumented</span>
<span id="L1060"><span class="lineNum">    1060</span>              :   template&lt;typename _Tp, typename _Alloc = allocator&lt;void&gt;&gt;</span>
<span id="L1061"><span class="lineNum">    1061</span>              :     auto</span>
<span id="L1062"><span class="lineNum">    1062</span>              :     __make_shared_arrN_tag(const _Alloc&amp; __a = _Alloc()) noexcept</span>
<span id="L1063"><span class="lineNum">    1063</span>              :     {</span>
<span id="L1064"><span class="lineNum">    1064</span>              :       using _Up = remove_all_extents_t&lt;_Tp&gt;;</span>
<span id="L1065"><span class="lineNum">    1065</span>              :       using _UpAlloc = __alloc_rebind&lt;_Alloc, _Up&gt;;</span>
<span id="L1066"><span class="lineNum">    1066</span>              :       size_t __n = sizeof(_Tp) / sizeof(_Up);</span>
<span id="L1067"><span class="lineNum">    1067</span>              :       return _Sp_counted_array_base&lt;_UpAlloc&gt;{_UpAlloc(__a), __n};</span>
<span id="L1068"><span class="lineNum">    1068</span>              :     }</span>
<span id="L1069"><span class="lineNum">    1069</span>              :   /// @endcond</span>
<span id="L1070"><span class="lineNum">    1070</span>              : </span>
<span id="L1071"><span class="lineNum">    1071</span>              :   template&lt;typename _Tp, typename _Alloc&gt;</span>
<span id="L1072"><span class="lineNum">    1072</span>              :     inline shared_ptr&lt;_BoundedArray&lt;_Tp&gt;&gt;</span>
<span id="L1073"><span class="lineNum">    1073</span>              :     allocate_shared(const _Alloc&amp; __a)</span>
<span id="L1074"><span class="lineNum">    1074</span>              :     {</span>
<span id="L1075"><span class="lineNum">    1075</span>              :       return shared_ptr&lt;_Tp&gt;(std::__make_shared_arrN_tag&lt;_Tp&gt;(__a));</span>
<span id="L1076"><span class="lineNum">    1076</span>              :     }</span>
<span id="L1077"><span class="lineNum">    1077</span>              : </span>
<span id="L1078"><span class="lineNum">    1078</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L1079"><span class="lineNum">    1079</span>              :     inline shared_ptr&lt;_BoundedArray&lt;_Tp&gt;&gt;</span>
<span id="L1080"><span class="lineNum">    1080</span>              :     make_shared()</span>
<span id="L1081"><span class="lineNum">    1081</span>              :     {</span>
<span id="L1082"><span class="lineNum">    1082</span>              :       return shared_ptr&lt;_Tp&gt;(std::__make_shared_arrN_tag&lt;_Tp&gt;());</span>
<span id="L1083"><span class="lineNum">    1083</span>              :     }</span>
<span id="L1084"><span class="lineNum">    1084</span>              : </span>
<span id="L1085"><span class="lineNum">    1085</span>              :   template&lt;typename _Tp, typename _Alloc&gt;</span>
<span id="L1086"><span class="lineNum">    1086</span>              :     inline shared_ptr&lt;_BoundedArray&lt;_Tp&gt;&gt;</span>
<span id="L1087"><span class="lineNum">    1087</span>              :     allocate_shared(const _Alloc&amp; __a, const remove_extent_t&lt;_Tp&gt;&amp; __u)</span>
<span id="L1088"><span class="lineNum">    1088</span>              :     {</span>
<span id="L1089"><span class="lineNum">    1089</span>              :       return shared_ptr&lt;_Tp&gt;(std::__make_shared_arrN_tag&lt;_Tp&gt;(__a),</span>
<span id="L1090"><span class="lineNum">    1090</span>              :                              std::__addressof(__u));</span>
<span id="L1091"><span class="lineNum">    1091</span>              :     }</span>
<span id="L1092"><span class="lineNum">    1092</span>              : </span>
<span id="L1093"><span class="lineNum">    1093</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L1094"><span class="lineNum">    1094</span>              :     inline shared_ptr&lt;_BoundedArray&lt;_Tp&gt;&gt;</span>
<span id="L1095"><span class="lineNum">    1095</span>              :     make_shared(const remove_extent_t&lt;_Tp&gt;&amp; __u)</span>
<span id="L1096"><span class="lineNum">    1096</span>              :     {</span>
<span id="L1097"><span class="lineNum">    1097</span>              :       return shared_ptr&lt;_Tp&gt;(std::__make_shared_arrN_tag&lt;_Tp&gt;(),</span>
<span id="L1098"><span class="lineNum">    1098</span>              :                              std::__addressof(__u));</span>
<span id="L1099"><span class="lineNum">    1099</span>              :     }</span>
<span id="L1100"><span class="lineNum">    1100</span>              : </span>
<span id="L1101"><span class="lineNum">    1101</span>              : #if __cpp_lib_smart_ptr_for_overwrite</span>
<span id="L1102"><span class="lineNum">    1102</span>              :   template&lt;typename _Tp, typename _Alloc&gt;</span>
<span id="L1103"><span class="lineNum">    1103</span>              :     inline shared_ptr&lt;_NotUnboundedArray&lt;_Tp&gt;&gt;</span>
<span id="L1104"><span class="lineNum">    1104</span>              :     allocate_shared_for_overwrite(const _Alloc&amp; __a)</span>
<span id="L1105"><span class="lineNum">    1105</span>              :     {</span>
<span id="L1106"><span class="lineNum">    1106</span>              :       if constexpr (is_array_v&lt;_Tp&gt;)</span>
<span id="L1107"><span class="lineNum">    1107</span>              :         return shared_ptr&lt;_Tp&gt;(std::__make_shared_arrN_tag&lt;_Tp&gt;(__a),</span>
<span id="L1108"><span class="lineNum">    1108</span>              :                                _Sp_overwrite_tag{});</span>
<span id="L1109"><span class="lineNum">    1109</span>              :       else</span>
<span id="L1110"><span class="lineNum">    1110</span>              :         {</span>
<span id="L1111"><span class="lineNum">    1111</span>              :           // Rebind the allocator to _Sp_overwrite_tag, so that the</span>
<span id="L1112"><span class="lineNum">    1112</span>              :           // relevant _Sp_counted_ptr_inplace specialization is used.</span>
<span id="L1113"><span class="lineNum">    1113</span>              :           using _Alloc2 = __alloc_rebind&lt;_Alloc, _Sp_overwrite_tag&gt;;</span>
<span id="L1114"><span class="lineNum">    1114</span>              :           _Alloc2 __a2 = __a;</span>
<span id="L1115"><span class="lineNum">    1115</span>              :           return shared_ptr&lt;_Tp&gt;(_Sp_alloc_shared_tag&lt;_Alloc2&gt;{__a2});</span>
<span id="L1116"><span class="lineNum">    1116</span>              :         }</span>
<span id="L1117"><span class="lineNum">    1117</span>              :     }</span>
<span id="L1118"><span class="lineNum">    1118</span>              : </span>
<span id="L1119"><span class="lineNum">    1119</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L1120"><span class="lineNum">    1120</span>              :     inline shared_ptr&lt;_NotUnboundedArray&lt;_Tp&gt;&gt;</span>
<span id="L1121"><span class="lineNum">    1121</span>              :     make_shared_for_overwrite()</span>
<span id="L1122"><span class="lineNum">    1122</span>              :     {</span>
<span id="L1123"><span class="lineNum">    1123</span>              :       if constexpr (is_array_v&lt;_Tp&gt;)</span>
<span id="L1124"><span class="lineNum">    1124</span>              :         return shared_ptr&lt;_Tp&gt;(std::__make_shared_arrN_tag&lt;_Tp&gt;(),</span>
<span id="L1125"><span class="lineNum">    1125</span>              :                                _Sp_overwrite_tag{});</span>
<span id="L1126"><span class="lineNum">    1126</span>              :       else</span>
<span id="L1127"><span class="lineNum">    1127</span>              :         {</span>
<span id="L1128"><span class="lineNum">    1128</span>              :           using _Alloc = allocator&lt;_Sp_overwrite_tag&gt;;</span>
<span id="L1129"><span class="lineNum">    1129</span>              :           return shared_ptr&lt;_Tp&gt;(_Sp_alloc_shared_tag&lt;_Alloc&gt;{{}});</span>
<span id="L1130"><span class="lineNum">    1130</span>              :         }</span>
<span id="L1131"><span class="lineNum">    1131</span>              :     }</span>
<span id="L1132"><span class="lineNum">    1132</span>              : </span>
<span id="L1133"><span class="lineNum">    1133</span>              :   template&lt;typename _Tp, typename _Alloc&gt;</span>
<span id="L1134"><span class="lineNum">    1134</span>              :     inline shared_ptr&lt;_UnboundedArray&lt;_Tp&gt;&gt;</span>
<span id="L1135"><span class="lineNum">    1135</span>              :     allocate_shared_for_overwrite(const _Alloc&amp; __a, size_t __n)</span>
<span id="L1136"><span class="lineNum">    1136</span>              :     {</span>
<span id="L1137"><span class="lineNum">    1137</span>              :       return shared_ptr&lt;_Tp&gt;(std::__make_shared_arr_tag&lt;_Tp&gt;(__n, __a),</span>
<span id="L1138"><span class="lineNum">    1138</span>              :                              _Sp_overwrite_tag{});</span>
<span id="L1139"><span class="lineNum">    1139</span>              :     }</span>
<span id="L1140"><span class="lineNum">    1140</span>              : </span>
<span id="L1141"><span class="lineNum">    1141</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L1142"><span class="lineNum">    1142</span>              :     inline shared_ptr&lt;_UnboundedArray&lt;_Tp&gt;&gt;</span>
<span id="L1143"><span class="lineNum">    1143</span>              :     make_shared_for_overwrite(size_t __n)</span>
<span id="L1144"><span class="lineNum">    1144</span>              :     {</span>
<span id="L1145"><span class="lineNum">    1145</span>              :       return shared_ptr&lt;_Tp&gt;(std::__make_shared_arr_tag&lt;_Tp&gt;(__n),</span>
<span id="L1146"><span class="lineNum">    1146</span>              :                              _Sp_overwrite_tag{});</span>
<span id="L1147"><span class="lineNum">    1147</span>              :     }</span>
<span id="L1148"><span class="lineNum">    1148</span>              : #endif // smart_ptr_for_overwrite</span>
<span id="L1149"><span class="lineNum">    1149</span>              : #endif // shared_ptr_arrays</span>
<span id="L1150"><span class="lineNum">    1150</span>              : </span>
<span id="L1151"><span class="lineNum">    1151</span>              :   /// std::hash specialization for shared_ptr.</span>
<span id="L1152"><span class="lineNum">    1152</span>              :   template&lt;typename _Tp&gt;</span>
<span id="L1153"><span class="lineNum">    1153</span>              :     struct hash&lt;shared_ptr&lt;_Tp&gt;&gt;</span>
<span id="L1154"><span class="lineNum">    1154</span>              :     : public __hash_base&lt;size_t, shared_ptr&lt;_Tp&gt;&gt;</span>
<span id="L1155"><span class="lineNum">    1155</span>              :     {</span>
<span id="L1156"><span class="lineNum">    1156</span>              :       size_t</span>
<span id="L1157"><span class="lineNum">    1157</span>              :       operator()(const shared_ptr&lt;_Tp&gt;&amp; __s) const noexcept</span>
<span id="L1158"><span class="lineNum">    1158</span>              :       {</span>
<span id="L1159"><span class="lineNum">    1159</span>              :         return std::hash&lt;typename shared_ptr&lt;_Tp&gt;::element_type*&gt;()(__s.get());</span>
<span id="L1160"><span class="lineNum">    1160</span>              :       }</span>
<span id="L1161"><span class="lineNum">    1161</span>              :     };</span>
<span id="L1162"><span class="lineNum">    1162</span>              : </span>
<span id="L1163"><span class="lineNum">    1163</span>              :   /// @} relates shared_ptr</span>
<span id="L1164"><span class="lineNum">    1164</span>              :   /// @} group pointer_abstractions</span>
<span id="L1165"><span class="lineNum">    1165</span>              : </span>
<span id="L1166"><span class="lineNum">    1166</span>              : #if __cplusplus &gt;= 201703L</span>
<span id="L1167"><span class="lineNum">    1167</span>              :   namespace __detail::__variant</span>
<span id="L1168"><span class="lineNum">    1168</span>              :   {</span>
<span id="L1169"><span class="lineNum">    1169</span>              :     template&lt;typename&gt; struct _Never_valueless_alt; // see &lt;variant&gt;</span>
<span id="L1170"><span class="lineNum">    1170</span>              : </span>
<span id="L1171"><span class="lineNum">    1171</span>              :     // Provide the strong exception-safety guarantee when emplacing a</span>
<span id="L1172"><span class="lineNum">    1172</span>              :     // shared_ptr into a variant.</span>
<span id="L1173"><span class="lineNum">    1173</span>              :     template&lt;typename _Tp&gt;</span>
<span id="L1174"><span class="lineNum">    1174</span>              :       struct _Never_valueless_alt&lt;std::shared_ptr&lt;_Tp&gt;&gt;</span>
<span id="L1175"><span class="lineNum">    1175</span>              :       : std::true_type</span>
<span id="L1176"><span class="lineNum">    1176</span>              :       { };</span>
<span id="L1177"><span class="lineNum">    1177</span>              : </span>
<span id="L1178"><span class="lineNum">    1178</span>              :     // Provide the strong exception-safety guarantee when emplacing a</span>
<span id="L1179"><span class="lineNum">    1179</span>              :     // weak_ptr into a variant.</span>
<span id="L1180"><span class="lineNum">    1180</span>              :     template&lt;typename _Tp&gt;</span>
<span id="L1181"><span class="lineNum">    1181</span>              :       struct _Never_valueless_alt&lt;std::weak_ptr&lt;_Tp&gt;&gt;</span>
<span id="L1182"><span class="lineNum">    1182</span>              :       : std::true_type</span>
<span id="L1183"><span class="lineNum">    1183</span>              :       { };</span>
<span id="L1184"><span class="lineNum">    1184</span>              :   }  // namespace __detail::__variant</span>
<span id="L1185"><span class="lineNum">    1185</span>              : #endif // C++17</span>
<span id="L1186"><span class="lineNum">    1186</span>              : </span>
<span id="L1187"><span class="lineNum">    1187</span>              : _GLIBCXX_END_NAMESPACE_VERSION</span>
<span id="L1188"><span class="lineNum">    1188</span>              : } // namespace</span>
<span id="L1189"><span class="lineNum">    1189</span>              : </span>
<span id="L1190"><span class="lineNum">    1190</span>              : #endif // _SHARED_PTR_H</span>
        </pre>
              </td>
            </tr>
          </table>
          <br>

          <table width="100%" border=0 cellspacing=0 cellpadding=0>
            <tr><td class="ruler"><img src="../../glass.png" width=3 height=3 alt=""></td></tr>
            <tr><td class="versionInfo">Generated by: <a href="https://github.com//linux-test-project/lcov" target="_parent">LCOV version 2.0-1</a></td></tr>
          </table>
          <br>

</body>
</html>
